private void addRemoveSlaves(
final MasterSlaveEntry entry,
final ClusterPartition currentPart,
final ClusterPartition newPart) {
Set<URI> removedSlaves = new HashSet<URI>(currentPart.getSlaveAddresses());
removedSlaves.removeAll(newPart.getSlaveAddresses());
for (URI uri : removedSlaves) {
currentPart.removeSlaveAddress(uri);
slaveDown(entry, uri.getHost(), uri.getPort(), FreezeReason.MANAGER);
log.info("slave {} removed for slot ranges: {}", uri, currentPart.getSlotRanges());
}
Set<URI> addedSlaves = new HashSet<URI>(newPart.getSlaveAddresses());
addedSlaves.removeAll(currentPart.getSlaveAddresses());
for (final URI uri : addedSlaves) {
Future<Void> future = entry.addSlave(uri.getHost(), uri.getPort());
future.addListener(
new FutureListener<Void>() {
@Override
public void operationComplete(Future<Void> future) throws Exception {
if (!future.isSuccess()) {
log.error("Can't add slave: " + uri, future.cause());
return;
}
currentPart.addSlaveAddress(uri);
entry.slaveUp(uri.getHost(), uri.getPort(), FreezeReason.MANAGER);
log.info("slave {} added for slot ranges: {}", uri, currentPart.getSlotRanges());
}
});
}
}
private void scan() throws IOException, JAXBException {
List<String> collectedUris = collectUris();
log.info(format("Collected URIs: %s (%d elements)", collectedUris, collectedUris.size()));
DataSource source = loadDataSource(getId());
if (!getUrl().equals(source.getBaseUrl()) && !baseUrl.equals(source.getBaseUrl()))
throw new IllegalArgumentException(
"Data source URL: " + source.getBaseUrl() + " doesn't match URL: " + getUrl());
Set<String> files = collectURIs(source);
Set<String> addedUris = new HashSet<>(collectedUris);
addedUris.removeAll(files);
Set<String> removedUris = new HashSet<>(files);
removedUris.removeAll(collectedUris);
if (hasDataSourcesServer()) {
if (addedUris.size() > 0) addUrisInChunks(source, addedUris);
if (removedUris.size() > 0) removeUris(source, removedUris);
}
log.info(
format(
"Added %d URIs, removed %d URIs out of %d URIs",
addCount, removeCount, collectedUris.size()));
}
private void updateSelections() {
/* Use set intersection/join's to figure out what updates
have been done */
/* First, find which temporary bonuses have been removed,
and which have been added */
Set<String> newValues = pc.getTempBonusNames();
Set<String> oldValues = new TreeSet<String>(tempBonusWidgets.keySet());
oldValues.removeAll(newValues);
newValues.removeAll(tempBonusWidgets.keySet());
if (!newValues.isEmpty()) {
addTempBonus(newValues);
}
if (!oldValues.isEmpty()) {
removeTempBonus(oldValues);
}
/* Now, same for equipment sets. */
newValues.clear();
oldValues.clear();
newValues.addAll(equipSet2Set(pc.getEquipSet()));
oldValues.addAll(eqSetWidgets.keySet());
oldValues.removeAll(newValues);
newValues.removeAll(eqSetWidgets.keySet());
if (!newValues.isEmpty()) {
addEquipSets(newValues);
}
if (!oldValues.isEmpty()) {
removeEquipSets(oldValues);
}
}
public void clear() {
checkIfLoaded();
resetSizeEstimator();
final Collection<Data> lockedKeys =
lockStore != null ? lockStore.getLockedKeys() : Collections.<Data>emptySet();
final Map<Data, Record> lockedRecords = new HashMap<Data, Record>(lockedKeys.size());
// Locked records should not be removed!
for (Data key : lockedKeys) {
Record record = records.get(key);
if (record != null) {
lockedRecords.put(key, record);
updateSizeEstimator(calculateRecordSize(record));
}
}
Set<Data> keysToDelete = records.keySet();
keysToDelete.removeAll(lockedRecords.keySet());
final MapStoreWrapper store = mapContainer.getStore();
// Use an ArrayList so that we don't trigger calls to equals or hashCode on the key objects
Collection<Object> keysObject = new ArrayList<Object>(keysToDelete.size());
for (Data key : keysToDelete) {
// todo ea have a clear(Keys) method for optimizations
removeIndex(key);
keysObject.add(mapService.toObject(key));
}
if (store != null) {
store.deleteAll(keysObject);
toBeRemovedKeys.removeAll(keysToDelete);
}
clearRecordsMap(lockedRecords);
cancelAssociatedSchedulers(keysToDelete);
resetAccessSequenceNumber();
}
/**
* Rules of updating AmazonInfo: - instanceId must exist - localIp/privateIp most exist -
* publicHostname does not necessarily need to exist (e.g. in vpc)
*/
/* visible for testing */ static boolean shouldUpdate(AmazonInfo newInfo, AmazonInfo oldInfo) {
if (newInfo.getMetadata().isEmpty()) {
logger.warn("Newly resolved AmazonInfo is empty, skipping an update cycle");
} else if (!newInfo.equals(oldInfo)) {
if (isBlank(newInfo.get(MetaDataKey.instanceId))) {
logger.warn("instanceId is blank, skipping an update cycle");
return false;
} else if (isBlank(newInfo.get(MetaDataKey.localIpv4))) {
logger.warn("localIpv4 is blank, skipping an update cycle");
return false;
} else {
Set<String> newKeys = new HashSet<>(newInfo.getMetadata().keySet());
Set<String> oldKeys = new HashSet<>(oldInfo.getMetadata().keySet());
Set<String> union = new HashSet<>(newKeys);
union.retainAll(oldKeys);
newKeys.removeAll(union);
oldKeys.removeAll(union);
for (String key : newKeys) {
logger.info("Adding new metadata {}={}", key, newInfo.getMetadata().get(key));
}
for (String key : oldKeys) {
logger.info("Removing old metadata {}={}", key, oldInfo.getMetadata().get(key));
}
}
return true;
}
return false;
}
public <T extends TaskRepository> void setRepositories(List<T> repositories) {
Set<TaskRepository> set = new HashSet<TaskRepository>(myRepositories);
set.removeAll(repositories);
myBadRepositories.removeAll(set); // remove all changed reps
myIssueCache.clear();
myRepositories.clear();
myRepositories.addAll(repositories);
reps:
for (T repository : repositories) {
if (repository.isShared() && repository.getUrl() != null) {
List<TaskProjectConfiguration.SharedServer> servers = getProjectConfiguration().servers;
TaskRepositoryType type = repository.getRepositoryType();
for (TaskProjectConfiguration.SharedServer server : servers) {
if (repository.getUrl().equals(server.url) && type.getName().equals(server.type)) {
continue reps;
}
}
TaskProjectConfiguration.SharedServer server = new TaskProjectConfiguration.SharedServer();
server.type = type.getName();
server.url = repository.getUrl();
servers.add(server);
}
}
}
private boolean solveHouse(House house, Set<Integer> combination) {
Set<Cell> selectedCells = new TreeSet<Cell>();
for (Cell cell : house.getCells()) {
if (cell.isSolved()) {
// This house already contains a cell with
// one of this quad's numbers.
if (combination.contains(cell.getDigit())) {
return false;
}
continue;
}
Collection<Integer> cellCandidates = cell.getCandidates();
if (cellCandidates.size() > getSetSize()) {
// Can't possibly be a subset
continue;
}
Set<Integer> cellCandidatesCopy = new HashSet<Integer>(cellCandidates);
cellCandidatesCopy.removeAll(combination);
if (cellCandidatesCopy.size() == 0) {
selectedCells.add(cell);
}
}
if (selectedCells.size() == getSetSize()) {
Set<Cell> houseCells = new HashSet<Cell>(house.getCells());
houseCells.removeAll(selectedCells);
boolean changed = false;
for (Cell cell : houseCells) {
if (cell.removeAll(combination)) {
changed = true;
}
}
return changed;
}
return false;
}
private Set<Vertex> computeMinVertexCover(Set<Vertex> side1, Set<Vertex> side2) {
Set<Vertex> konigSet = new HashSet<Vertex>();
Set<Vertex> unmatched = new TreeSet<Vertex>(side1);
unmatched.removeAll(matches);
// System.out.println("Matches: " + matches);
// System.out.println("side 1 unmatched set: " + unmatched);
for (Vertex v : unmatched) {
konigDFS(konigSet, v, false);
}
// System.out.println("Konig set: " + konigSet);
Set<Vertex> result = new HashSet<Vertex>(side2);
result.retainAll(konigSet);
// System.out.println("side 2 intersect konigSet: " + result);
Set<Vertex> side1notInKonigSet = new HashSet<Vertex>(side1);
side1notInKonigSet.removeAll(konigSet);
// System.out.println("side 1 not in Konig set: " + side1notInKonigSet);
result.addAll(side1notInKonigSet);
return result;
}
private List<Node> getClosestNodes(
Key k, int n, int index, Bucket[] buckets, Collection<Node> exclude) {
final List<Node> $ = new ArrayList<Node>();
final Set<Node> t = new HashSet<Node>();
if (index < 0) index = 0;
buckets[index].addNodesTo($);
if ($.size() < n) {
// look in other buckets
for (int i = 1; $.size() < n; ++i) {
if (index + i < buckets.length) {
buckets[index + i].addNodesTo(t);
t.removeAll(exclude);
$.addAll(t);
t.clear();
}
if (0 <= index - i) {
buckets[index - i].addNodesTo(t);
t.removeAll(exclude);
$.addAll(t);
t.clear();
}
if (buckets.length <= index + i && index - i < 0) break;
}
}
return $;
}
@Override
public void apply() throws ConfigurationException {
List<X509Certificate> existing = myTrustManager.getCertificates();
Set<X509Certificate> added = new HashSet<X509Certificate>(myCertificates);
added.removeAll(existing);
Set<X509Certificate> removed = new HashSet<X509Certificate>(existing);
removed.removeAll(myCertificates);
for (X509Certificate certificate : added) {
if (!myTrustManager.addCertificate(certificate)) {
throw new ConfigurationException(
"Cannot add certificate for " + getCommonName(certificate), "Cannot Add Certificate");
}
}
for (X509Certificate certificate : removed) {
if (!myTrustManager.removeCertificate(certificate)) {
throw new ConfigurationException(
"Cannot remove certificate for " + getCommonName(certificate),
"Cannot Remove Certificate");
}
}
CertificateManager.Config state = CertificateManager.getInstance().getState();
state.ACCEPT_AUTOMATICALLY = myAcceptAutomatically.isSelected();
state.CHECK_HOSTNAME = myCheckHostname.isSelected();
state.CHECK_VALIDITY = myCheckValidityPeriod.isSelected();
}
private void checkSlotsMigration(Collection<ClusterPartition> newPartitions) {
List<ClusterPartition> currentPartitions =
new ArrayList<ClusterPartition>(lastPartitions.values());
for (ClusterPartition currentPartition : currentPartitions) {
for (ClusterPartition newPartition : newPartitions) {
if (!currentPartition.getNodeId().equals(newPartition.getNodeId())) {
continue;
}
Set<ClusterSlotRange> addedSlots =
new HashSet<ClusterSlotRange>(newPartition.getSlotRanges());
addedSlots.removeAll(currentPartition.getSlotRanges());
MasterSlaveEntry entry = getEntry(currentPartition.getSlotRanges().iterator().next());
currentPartition.addSlotRanges(addedSlots);
for (ClusterSlotRange slot : addedSlots) {
entry.addSlotRange(slot);
addEntry(slot, entry);
log.info("{} slot added for {}", slot, entry.getClient().getAddr());
lastPartitions.put(slot, currentPartition);
}
Set<ClusterSlotRange> removedSlots =
new HashSet<ClusterSlotRange>(currentPartition.getSlotRanges());
removedSlots.removeAll(newPartition.getSlotRanges());
lastPartitions.keySet().removeAll(removedSlots);
currentPartition.removeSlotRanges(removedSlots);
for (ClusterSlotRange slot : removedSlots) {
log.info("{} slot removed for {}", slot, entry.getClient().getAddr());
entry.removeSlotRange(slot);
removeMaster(slot);
}
}
}
}
/**
* Get the task Map which the task is alive and will be kept Only when type is
* ASSIGN_TYPE_MONITOR, it is valid
*
* @param defaultContext
* @param needAssigns
* @return
*/
public Map<Integer, ResourceAssignment> getKeepAssign(
DefaultTopologyAssignContext defaultContext, Set<Integer> needAssigns) {
Set<Integer> keepAssignIds = new HashSet<Integer>();
keepAssignIds.addAll(defaultContext.getAllTaskIds());
keepAssignIds.removeAll(defaultContext.getUnstoppedTaskIds());
keepAssignIds.removeAll(needAssigns);
Map<Integer, ResourceAssignment> keeps = new HashMap<Integer, ResourceAssignment>();
if (keepAssignIds.isEmpty()) {
return keeps;
}
Assignment oldAssignment = defaultContext.getOldAssignment();
if (oldAssignment == null) {
return keeps;
}
Map<Integer, ResourceAssignment> olds = oldAssignment.getTaskToResource();
for (Integer task : keepAssignIds) {
ResourceAssignment oldResource = olds.get(task);
if (oldResource == null) {
LOG.warn("No old assignment of " + task + ", " + defaultContext.toDetailString());
continue;
}
keeps.put(task, oldResource);
}
return keeps;
}
/** @return the new constraints enforced at this handle, that aren't yet enforced at parents */
public Set<PConstraint> getDeltaEnforcedConstraints() {
Set<PConstraint> result = CollectionsFactory.getSet(); // new HashSet<PConstraint>(constraints);
if (primaryParentStub != null) result.removeAll(primaryParentStub.getAllEnforcedConstraints());
if (secondaryParentStub != null)
result.removeAll(secondaryParentStub.getAllEnforcedConstraints());
return result;
}
/** removeAll removes all elements from the given collection */
public void testRemoveAll() {
Set full = populatedSet(3);
assertTrue(full.removeAll(Arrays.asList(one, two)));
assertEquals(1, full.size());
assertFalse(full.removeAll(Arrays.asList(one, two)));
assertEquals(1, full.size());
}
private void walk(String authority, Path root, String prefix, int count) throws IOException {
Path cachePath = BASE_PATH.resolve(authority);
Path dirPath = Paths.get(cachePath.toString(), root.toString());
Set<String> fileNames =
Files.walk(dirPath)
.filter(p -> p.toString().endsWith(".txt"))
.map(p -> Paths.get(p.toAbsolutePath().toString()))
.map(cachePath::relativize)
.map(Object::toString)
.collect(Collectors.toSet());
assertFalse(fileNames.isEmpty());
Set<String> expected =
IntStream.range(0, count).mapToObj(i -> prefix + i + ".txt").collect(Collectors.toSet());
assertFalse(expected.isEmpty());
Set<String> extra = new HashSet<>(fileNames);
extra.removeAll(expected);
if (!extra.isEmpty()) {
System.out.println("Extra entries " + extra);
}
assertTrue("Extra entries ", extra.isEmpty());
Set<String> missing = new HashSet<>(expected);
missing.removeAll(fileNames);
if (!extra.isEmpty()) {
System.out.println("Missing entries " + missing);
}
assertTrue("Missing entries", missing.isEmpty());
}
/**
* Given a set of SCC nodes make this the lead member of the SCC and reroute all incoming and
* outgoing links accordingly. This eager rewrite is based on the assumption that there are few
* cycles so it is better to rewrite once and keep the graph easy to traverse.
*/
public void makeLeadNodeFor(Set<GraphNode> members) {
// Accumulate all successors
Set<GraphNode> newSucc = new HashSet<>();
Set<GraphNode> newSuccClosed = new HashSet<>();
for (GraphNode n : members) {
newSucc.addAll(n.succ);
newSuccClosed.addAll(n.succClosed);
}
newSucc.removeAll(members);
newSuccClosed.removeAll(members);
succ = newSucc;
succClosed = newSuccClosed;
// Rewrite all direct successors to have us as predecessor
for (GraphNode n : succ) {
n.pred.removeAll(members);
n.pred.add(this);
}
// Find all predecessor nodes and relink link them to point to us
Set<GraphNode> done = new HashSet<>();
Set<GraphNode> newAliases = new HashSet<>();
for (GraphNode member : members) {
addSiblings(newAliases, member);
}
becomeLeaderOf(newAliases);
for (GraphNode n : members) {
if (n != this) {
pred.addAll(n.pred);
n.relocateAllRefTo(this, done);
n.becomeSubordinateOf(this);
}
}
pred.removeAll(members);
}
public void testKeySetRemoveAllNullFromEmpty() {
final Map<K, V> map;
try {
map = makeEmptyMap();
} catch (UnsupportedOperationException e) {
return;
}
Set<K> keySet = map.keySet();
if (supportsRemove) {
try {
keySet.removeAll(null);
fail("Expected NullPointerException.");
} catch (NullPointerException e) {
// Expected.
}
} else {
try {
keySet.removeAll(null);
fail("Expected UnsupportedOperationException or NullPointerException.");
} catch (UnsupportedOperationException e) {
// Expected.
} catch (NullPointerException e) {
// Expected.
}
}
assertInvariants(map);
}
private final synchronized List<? extends PathResourceImplementation> refresh() {
List<Dependency> l = getDeps().all();
Set<DependencyPathResourceImplementation> old;
Set<DependencyPathResourceImplementation> nue;
synchronized (this) {
old = new TreeSet<DependencyPathResourceImplementation>(resources);
nue = new TreeSet<DependencyPathResourceImplementation>();
for (int i = 0; i < l.size(); i++) {
nue.add(new DependencyPathResourceImplementation(l.get(i), i));
}
if (resources.equals(nue)) {
return new ArrayList<PathResourceImplementation>(resources);
}
Set<DependencyPathResourceImplementation> removed =
new HashSet<DependencyPathResourceImplementation>(old);
removed.removeAll(nue);
Set<DependencyPathResourceImplementation> added =
new HashSet<DependencyPathResourceImplementation>(nue);
added.removeAll(old);
for (DependencyPathResourceImplementation d : removed) {
resources.remove(d);
}
for (DependencyPathResourceImplementation d : added) {
resources.add(d);
}
}
List<? extends PathResourceImplementation> result =
new ArrayList<PathResourceImplementation>(nue);
fire(ClassPathImplementation.PROP_RESOURCES, old, result);
return result;
}
// /////////////////////////////////////////////////////////////////
// // private methods ////
// Recursively compute the set of free variables for all actors
// deeply contained in the given model.
private Set _freeVariables(Entity model) throws IllegalActionException {
// First get the free variables of contained actors.
Set set = new HashSet();
if (model instanceof CompositeEntity) {
for (Iterator entities = ((CompositeEntity) model).entityList().iterator();
entities.hasNext(); ) {
Entity entity = (Entity) entities.next();
set.addAll(_freeVariables(entity));
}
}
// Next, compute the set of variable names defined in this container.
Set variableNames = new HashSet();
for (Iterator variables = model.attributeList(Variable.class).iterator();
variables.hasNext(); ) {
Variable variable = (Variable) variables.next();
variableNames.add(variable.getName());
}
variableNames = Collections.unmodifiableSet(variableNames);
// Free variables of contained actors that are defined in this
// container are not free variables of this container.
set.removeAll(variableNames);
// Iterate over all the variables of this container, and add in
// any free variables they reference.
PtParser parser = new PtParser();
ParseTreeFreeVariableCollector collector = new ParseTreeFreeVariableCollector();
for (Iterator variables = model.attributeList(Variable.class).iterator();
variables.hasNext(); ) {
Variable variable = (Variable) variables.next();
String expression = variable.getExpression();
ASTPtRootNode root;
if (variable.isStringMode()) {
root = parser.generateStringParseTree(expression);
} else {
root = parser.generateParseTree(expression);
}
Set freeIdentifiers = new HashSet(collector.collectFreeVariables(root));
// Identifiers that reference other variables in the same container
// are bound, not free.
Set tempSet = new HashSet(variableNames);
tempSet.remove(variable.getName());
freeIdentifiers.removeAll(tempSet);
set.addAll(freeIdentifiers);
}
_entityToFreeVariableNameSet.put(model, set);
return set;
}
protected static Set<String> computeKeywords(Grammar grammar) {
Set<String> keywords = new HashSet<String>(GrammarUtil.getAllKeywords(grammar));
keywords.removeAll(getAllKeywords(grammar, "UnrestrictedName"));
keywords.removeAll(getAllKeywords(grammar, "EssentialOCLReservedKeyword"));
keywords.removeAll(getAllKeywords(grammar, "RestrictedKeywords"));
keywords.removeAll(getAllKeywords(grammar, "CollectionTypeIdentifier"));
keywords.removeAll(getAllKeywords(grammar, "PrimitiveTypeIdentifier"));
return keywords;
}
/**
* Update the underlying connectiosStore.
*
* @param oldElement - old element
* @param newElement - new element
* @throws Exception
*/
protected void updateConnectionStore(E oldElement, E newElement) throws Exception {
if (rollingEnabled && oldElement == null) {
rollingTypeahead.offer(newElement);
} else {
long scn = newElement.getTimestamp();
int elemId = newElement.getElementId();
if (oldElement == null) {
// Insert operation
for (String term : newElement.getTerms()) {
int len = Math.min(term.length(), maxKeyLength);
for (int i = 1; i <= len; i++) {
String source = term.substring(0, i);
connectionsStore.addConnection(source, elemId, scn);
}
}
} else if (newElement.getTimestamp() >= getHWMark()) {
// Update operation
Set<String> oldPrefixes = new HashSet<String>();
Set<String> newPrefixes = new HashSet<String>();
for (String term : oldElement.getTerms()) {
int len = Math.min(term.length(), maxKeyLength);
for (int i = 1; i <= len; i++) {
String source = term.substring(0, i);
oldPrefixes.add(source);
}
}
for (String term : newElement.getTerms()) {
int len = Math.min(term.length(), maxKeyLength);
for (int i = 1; i <= len; i++) {
String source = term.substring(0, i);
newPrefixes.add(source);
}
}
// Calculate intersection
Set<String> commonPrefixes = new HashSet<String>();
commonPrefixes.addAll(oldPrefixes);
commonPrefixes.retainAll(newPrefixes);
newPrefixes.removeAll(commonPrefixes);
for (String source : newPrefixes) {
connectionsStore.addConnection(source, elemId, scn);
}
oldPrefixes.removeAll(commonPrefixes);
for (String source : oldPrefixes) {
connectionsStore.removeConnection(source, elemId, scn);
}
} else {
logger.info("ignored element: " + newElement);
}
}
}
private void scan() throws OperationFailedException {
try {
scanLock.lockInterruptibly();
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
return;
}
try {
if (scanEnabled) { // confirm the scan is still wanted
log.tracef(
"Scanning directory %s for deployment content changes",
deploymentDir.getAbsolutePath());
final List<ModelNode> updates = new ArrayList<ModelNode>();
Map<String, File> foundDeployed = new HashMap<String, File>();
Set<String> newlyAdded = new HashSet<String>();
Set<String> registeredDeployments = getDeploymentNames();
scanDirectory(deploymentDir, updates, foundDeployed, newlyAdded, registeredDeployments);
// Add remove actions to the plan for anything we count as
// deployed that we didn't find on the scan
Set<String> toRemove = new HashSet<String>(deployed);
toRemove.removeAll(foundDeployed.keySet());
toRemove.removeAll(newlyAdded); // in case user removed the marker and added replacement
for (String missing : toRemove) {
updates.add(getUndeployOperation(missing));
updates.add(getRemoveOperation(missing));
}
if (updates.size() > 0) {
if (log.isDebugEnabled()) {
for (ModelNode update : updates) {
log.debugf("Deployment scan of [%s] found update action [%s]", deploymentDir, update);
}
}
Operation composite = getCompositeUpdate(updates);
ModelNode results = serverController.execute(composite);
// System.out.println(composite);
// System.out.println(results);
// FIXME deal with result
}
// Throw away any found marker files that we didn't already know about
Set<String> validFinds = cleanSpuriousMarkerFiles(foundDeployed);
validFinds.addAll(newlyAdded);
this.deployed = validFinds;
log.tracef("Scan complete");
}
} finally {
scanLock.unlock();
}
}
/**
* Get all users that don't have any special status in this channel. This means that they aren't
* ops, have voice, superops, halops, or owners in this channel
*
* @return An <i>unmodifiable</i> Set (IE snapshot) of non-special users in the channel
*/
public Set<User> getNormalUsers() {
// Build set
Set<User> normalUsers = new HashSet<User>(bot.getUsers(this));
normalUsers.removeAll(ops);
normalUsers.removeAll(voices);
normalUsers.removeAll(halfOps);
normalUsers.removeAll(superOps);
normalUsers.removeAll(owners);
return Collections.unmodifiableSet(normalUsers);
}
/**
* Finds set of all defs in function given (defSites). Adds parameters of function to this set:
* defSites. Finds all variables that are referenced in the function given (alf.names).
* windowProps are all global properties available. Closures = alf.names - defSites - windowProps
*
* @param n root node of the function who's closures are to be found
* @return set of closure names
*/
private Set<String> findClosures(Node n) {
Set<String> closureVars = null;
SimpleDefinitionFinder defFinder = new SimpleDefinitionFinder(compiler);
defFinder.process(externs, n.getLastChild());
Collection<DefinitionSite> defSites = defFinder.getDefinitionSites();
Set<String> localDefs = new HashSet<String>();
for (DefinitionSite site : defSites) {
if (site.node.getType() == Token.GETPROP) continue;
String def = site.node.getString();
if (def.length() > 0) {
localDefs.add(def);
}
}
// adding params to function as defs
Node origParamNode = n.getChildAtIndex(1);
for (int i = 0; i < origParamNode.getChildCount(); i++) {
String temp = origParamNode.getChildAtIndex(i).getString();
localDefs.add(temp);
}
// System.out.println("\nPrinting LOCAL def sites:" + defs);
/*SimpleDefinitionFinder defFinder1 = new SimpleDefinitionFinder(compiler);
defFinder1.process(externs, root);
Collection<DefinitionSite> defSites1 = defFinder1.getDefinitionSites();
Set<String> defs1 = new HashSet<String>();
for(DefinitionSite site1: defSites1){
if (site1.node.getType() == Token.GETPROP) continue;
String def = site1.node.getString();
if (def.length() > 0){
defs1.add(def);
}
}
System.out.println("\nPrinting Global def sites:" + defs1);*/
AllNamesFinder alf = new AllNamesFinder(compiler);
NodeTraversal.traverse(compiler, n.getLastChild(), alf);
// System.out.println("all names: " + alf.names);
closureVars = alf.names;
closureVars.removeAll(localDefs);
closureVars.removeAll(Props.windowProps);
closureVars.remove(
"this"); // since 'this' is later modified to $$_self we don't need to consider this as
// closure
return closureVars;
}
private void checkSlotsChange(
ClusterServersConfig cfg, Collection<ClusterPartition> newPartitions) {
checkSlotsMigration(newPartitions);
Collection<ClusterSlotRange> newPartitionsSlots = slots(newPartitions);
Set<ClusterSlotRange> removedSlots = new HashSet<ClusterSlotRange>(lastPartitions.keySet());
removedSlots.removeAll(newPartitionsSlots);
lastPartitions.keySet().removeAll(removedSlots);
if (!removedSlots.isEmpty()) {
log.info("{} slot ranges found to remove", removedSlots);
}
for (ClusterSlotRange slot : removedSlots) {
MasterSlaveEntry entry = removeMaster(slot);
entry.removeSlotRange(slot);
if (entry.getSlotRanges().isEmpty()) {
entry.shutdownMasterAsync();
log.info("{} master and slaves for it removed", entry.getClient().getAddr());
}
}
Set<ClusterSlotRange> addedSlots = new HashSet<ClusterSlotRange>(newPartitionsSlots);
addedSlots.removeAll(lastPartitions.keySet());
if (!addedSlots.isEmpty()) {
log.info("{} slots found to add", addedSlots);
}
for (final ClusterSlotRange slot : addedSlots) {
ClusterPartition partition = find(newPartitions, slot);
boolean masterFound = false;
for (MasterSlaveEntry entry : getEntries().values()) {
if (entry.getClient().getAddr().equals(partition.getMasterAddr())) {
addEntry(slot, entry);
lastPartitions.put(slot, partition);
masterFound = true;
break;
}
}
if (!masterFound) {
Future<Collection<Future<Void>>> future = addMasterEntry(partition, cfg);
future.addListener(
new FutureListener<Collection<Future<Void>>>() {
@Override
public void operationComplete(Future<Collection<Future<Void>>> future)
throws Exception {
if (!future.isSuccess()) {
log.error(
"New cluster slot range " + slot + " without master node detected",
future.cause());
}
}
});
}
}
}
/**
* removeNoise() methods removes inconsistent data and missing values. For consistency where are
* there are reviews relevant and non relevant for each item are considered.
*/
private void removeNoise() {
Set<String> nonRel = itemUserMatrixNonRelevant.keySet();
Set<String> rel = itemUserMatrixRelevant.keySet();
Set<String> noise = new LinkedHashSet<String>(rel);
Set<String> iter = new LinkedHashSet<String>(rel);
Set<String> niter = new LinkedHashSet<String>(nonRel);
noise.retainAll(nonRel);
iter.removeAll(noise);
niter.removeAll(noise);
System.out.println(userItemMatrix.size());
System.out.println(userItemMatrixRelevant.size());
System.out.println(itemUserMatrixRelevant.size());
System.out.println(itemUserMatrixNonRelevant.size());
for (String unwanted : iter) {
itemUserMatrixRelevant.remove(unwanted);
itemUserMatrixNonRelevant.remove(unwanted);
}
for (Entry<String, ArrayList<String>> entry : userItemMatrix.entrySet()) {
entry.getValue().removeAll(iter);
}
for (Entry<String, ArrayList<String>> entry : userItemMatrixRelevant.entrySet()) {
entry.getValue().removeAll(iter);
}
for (String unwanted : niter) {
itemUserMatrixRelevant.remove(unwanted);
itemUserMatrixNonRelevant.remove(unwanted);
}
for (Entry<String, ArrayList<String>> entry : userItemMatrix.entrySet()) {
entry.getValue().removeAll(niter);
}
for (Entry<String, ArrayList<String>> entry : userItemMatrixRelevant.entrySet()) {
entry.getValue().removeAll(niter);
}
System.out.println(userItemMatrix.size());
System.out.println(userItemMatrixRelevant.size());
System.out.println(itemUserMatrixRelevant.size());
System.out.println(itemUserMatrixNonRelevant.size());
int maxSize = 0;
String userid = "";
for (Entry<String, ArrayList<String>> entry : userItemMatrixRelevant.entrySet()) {
if (entry.getValue().size() > maxSize) {
maxSize = entry.getValue().size();
userid = entry.getKey();
}
}
System.out.println("Choose user " + userid);
}
private void doUpdateModelsSet() {
assertCanChange();
for (SModel model : getModels()) {
if (model instanceof EditableSModel && ((EditableSModel) model).isChanged()) {
LOG.warn(
"Trying to reload module "
+ getModuleName()
+ " which contains a non-saved model '"
+ model.getName()
+ "'. To prevent data loss, MPS will not update models in this module. "
+ "Please save your work and restart MPS. See MPS-18743 for details.");
return;
}
}
Set<ModelRoot> toRemove = new HashSet<ModelRoot>(mySModelRoots);
Set<ModelRoot> toUpdate = new HashSet<ModelRoot>(mySModelRoots);
Set<ModelRoot> toAttach = new HashSet<ModelRoot>();
for (ModelRoot root : loadRoots()) {
try {
if (mySModelRoots.contains(root)) {
toRemove.remove(root);
} else {
toAttach.add(root);
}
} catch (Exception e) {
LOG.error(
"Error loading models from root `"
+ root.getPresentation()
+ "'. Requested by: "
+ this,
e);
}
}
toUpdate.removeAll(toRemove);
for (ModelRoot modelRoot : toRemove) {
((ModelRootBase) modelRoot).dispose();
}
mySModelRoots.removeAll(toRemove);
for (ModelRoot modelRoot : toAttach) {
ModelRootBase rootBase = (ModelRootBase) modelRoot;
rootBase.setModule(this);
mySModelRoots.add(modelRoot);
rootBase.attach();
}
for (ModelRoot modelRoot : toUpdate) {
((ModelRootBase) modelRoot).update();
}
}
public synchronized void assertAllEqual(int expectedCount) throws IOException {
Set<Uid> primaryIds = getShardDocUIDs(primary);
assertThat(primaryIds.size(), equalTo(expectedCount));
for (IndexShard replica : replicas) {
Set<Uid> replicaIds = getShardDocUIDs(replica);
Set<Uid> temp = new HashSet<>(primaryIds);
temp.removeAll(replicaIds);
assertThat(replica.routingEntry() + " is missing docs", temp, empty());
temp = new HashSet<>(replicaIds);
temp.removeAll(primaryIds);
assertThat(replica.routingEntry() + " has extra docs", temp, empty());
}
}
private void checkAllArticlesAreAllocatedOrReversed(
Collection<? extends Article> deletedArticles) {
ArticleStatusCheckResult articleStatusCheckResult =
new ArticleStatusCheckResult(getArticleContainerEdit().getArticles());
articlesWithWrongState.addAll(articleStatusCheckResult.getNotAllocatedNorReversedArticles());
articlesWithWrongState.removeAll(articleStatusCheckResult.getAllocatedOrReversedArticles());
if (deletedArticles != null) articlesWithWrongState.removeAll(deletedArticles);
if (buttonComp != null && !buttonComp.isDisposed())
buttonComp.setEnabled(articlesWithWrongState.isEmpty());
}
@Override
public void set(
final SecurityContext securityContext,
final NodeInterface targetNode,
final Iterable<S> collection)
throws FrameworkException {
final App app = StructrApp.getInstance(securityContext);
final Set<S> toBeDeleted =
new LinkedHashSet<>(Iterables.toList(get(securityContext, targetNode, null)));
final Set<S> toBeCreated = new LinkedHashSet<>();
if (collection != null) {
Iterables.addAll(toBeCreated, collection);
}
// create intersection of both sets
final Set<S> intersection = new LinkedHashSet<>(toBeCreated);
intersection.retainAll(toBeDeleted);
// intersection needs no change
toBeCreated.removeAll(intersection);
toBeDeleted.removeAll(intersection);
// remove existing relationships
for (S sourceNode : toBeDeleted) {
for (AbstractRelationship rel : targetNode.getIncomingRelationships()) {
final String relTypeName = rel.getRelType().name();
final String desiredRelType = relation.name();
if (relTypeName.equals(desiredRelType) && rel.getSourceNode().equals(sourceNode)) {
app.delete(rel);
}
}
}
// create new relationships
for (S sourceNode : toBeCreated) {
relation.ensureCardinality(securityContext, sourceNode, targetNode);
app.create(
sourceNode,
targetNode,
relation.getClass(),
getNotionProperties(securityContext, relation.getClass(), sourceNode.getUuid()));
}
}