public static void main(String[] args) throws Exception {
CommandLineOptionHelper helper = new CommandLineOptionHelper(args);
GridRole role = GridRole.find(args);
if (role == null) {
printInfoAboutRoles(helper);
return;
}
if (helper.isParamPresent("-help") || helper.isParamPresent("-h")) {
if (launchers.containsKey(role)) {
launchers.get(role).printUsage();
} else {
printInfoAboutRoles(helper);
}
return;
}
configureLogging(helper);
if (launchers.containsKey(role)) {
try {
launchers.get(role).launch(args, log);
} catch (Exception e) {
launchers.get(role).printUsage();
e.printStackTrace();
}
} else {
throw new GridConfigurationException("Unknown role: " + role);
}
}
public Optional<Long> getArtifactSizeBytes() {
if (eventInfo.containsKey(ARTIFACT_SIZE_BYTES_KEY)) {
return Optional.of((long) eventInfo.get(ARTIFACT_SIZE_BYTES_KEY));
}
return Optional.absent();
}
/**
* Produces a factory that allows the union of the grants, and intersects policies where they
* overlap on a particular granted attribute or element name.
*/
public PolicyFactory and(PolicyFactory f) {
ImmutableMap.Builder<String, ElementAndAttributePolicies> b = ImmutableMap.builder();
// Merge this and f into a map of element names to attribute policies.
for (Map.Entry<String, ElementAndAttributePolicies> e : policies.entrySet()) {
String elName = e.getKey();
ElementAndAttributePolicies p = e.getValue();
ElementAndAttributePolicies q = f.policies.get(elName);
if (q != null) {
p = p.and(q);
} else {
// Mix in any globals that are not already taken into account in this.
p = p.andGlobals(f.globalAttrPolicies);
}
b.put(elName, p);
}
// Handle keys that are in f but not in this.
for (Map.Entry<String, ElementAndAttributePolicies> e : f.policies.entrySet()) {
String elName = e.getKey();
if (!policies.containsKey(elName)) {
ElementAndAttributePolicies p = e.getValue();
// Mix in any globals that are not already taken into account in this.
p = p.andGlobals(f.globalAttrPolicies);
b.put(elName, p);
}
}
ImmutableSet<String> textContainers;
if (this.textContainers.containsAll(f.textContainers)) {
textContainers = this.textContainers;
} else if (f.textContainers.containsAll(this.textContainers)) {
textContainers = f.textContainers;
} else {
textContainers =
ImmutableSet.<String>builder()
.addAll(this.textContainers)
.addAll(f.textContainers)
.build();
}
ImmutableMap<String, AttributePolicy> allGlobalAttrPolicies;
if (f.globalAttrPolicies.isEmpty()) {
allGlobalAttrPolicies = this.globalAttrPolicies;
} else if (this.globalAttrPolicies.isEmpty()) {
allGlobalAttrPolicies = f.globalAttrPolicies;
} else {
ImmutableMap.Builder<String, AttributePolicy> ab = ImmutableMap.builder();
for (Map.Entry<String, AttributePolicy> e : this.globalAttrPolicies.entrySet()) {
String attrName = e.getKey();
ab.put(
attrName, AttributePolicy.Util.join(e.getValue(), f.globalAttrPolicies.get(attrName)));
}
for (Map.Entry<String, AttributePolicy> e : f.globalAttrPolicies.entrySet()) {
String attrName = e.getKey();
if (!this.globalAttrPolicies.containsKey(attrName)) {
ab.put(attrName, e.getValue());
}
}
allGlobalAttrPolicies = ab.build();
}
return new PolicyFactory(b.build(), textContainers, allGlobalAttrPolicies);
}
private Call.DisconnectCause translateDisconnectCauseFromTelephony(
Connection.DisconnectCause causeSource) {
if (CAUSE_MAP.containsKey(causeSource)) {
return CAUSE_MAP.get(causeSource);
}
return Call.DisconnectCause.UNKNOWN;
}
@Nullable
@Override
public SkyValue compute(SkyKey skyKey, Environment env)
throws SkyFunctionException, InterruptedException {
ImmutableMap<Action, ConflictException> badActions = PrecomputedValue.BAD_ACTIONS.get(env);
ConfiguredTargetValue ctValue =
(ConfiguredTargetValue)
env.getValue(ConfiguredTargetValue.key((ConfiguredTargetKey) skyKey.argument()));
SkyframeDependencyResolver resolver =
buildViewProvider.getSkyframeBuildView().createDependencyResolver(env);
if (env.valuesMissing()) {
return null;
}
for (Action action : ctValue.getActions()) {
if (badActions.containsKey(action)) {
throw new ActionConflictFunctionException(badActions.get(action));
}
}
ConfiguredTarget ct = ctValue.getConfiguredTarget();
TargetAndConfiguration ctgValue =
new TargetAndConfiguration(ct.getTarget(), ct.getConfiguration());
Set<ConfigMatchingProvider> configConditions =
getConfigurableAttributeConditions(ctgValue, env);
if (configConditions == null) {
return null;
}
ListMultimap<Attribute, Dependency> deps;
try {
BuildConfiguration hostConfiguration =
buildViewProvider.getSkyframeBuildView().getHostConfiguration(ct.getConfiguration());
deps =
resolver.dependentNodeMap(
ctgValue, hostConfiguration, /*aspect=*/ null, configConditions);
if (ct.getConfiguration() != null && ct.getConfiguration().useDynamicConfigurations()) {
deps =
ConfiguredTargetFunction.trimConfigurations(
env, ctgValue, deps, hostConfiguration, ruleClassProvider);
}
} catch (EvalException e) {
throw new PostConfiguredTargetFunctionException(e);
} catch (ConfiguredTargetFunction.DependencyEvaluationException e) {
throw new PostConfiguredTargetFunctionException(e);
}
env.getValues(Iterables.transform(deps.values(), TO_KEYS));
if (env.valuesMissing()) {
return null;
}
return new PostConfiguredTargetValue(ct);
}
@Test
public void testCollectionInitial() {
ImmutableMap<Integer, Integer> of = ImmutableMap.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Assert.assertTrue(of.containsKey(1));
ArrayList<Integer> arrayList = Lists.newArrayList(1, 2, 3, 4);
Assert.assertTrue(arrayList.contains(1));
HashSet<Integer> hashSet = Sets.newHashSet(1, 2);
Assert.assertTrue(hashSet.contains(1));
}
static ImmutableMap<String, String> withDefaults(
ImmutableMap<String, String> map, ImmutableMap<String, String> defaults) {
ImmutableMap.Builder<String, String> builder =
ImmutableMap.<String, String>builder().putAll(map);
for (ImmutableMap.Entry<String, String> entry : defaults.entrySet()) {
if (!map.containsKey(entry.getKey())) {
builder = builder.put(entry.getKey(), entry.getValue());
}
}
return builder.build();
}
/**
* @return the feature with the given {@code name}.
* @throws InvalidConfigurationException if no feature with the given name was configured.
*/
private Feature getFeatureOrFail(String name, String reference)
throws InvalidConfigurationException {
if (!featuresByName.containsKey(name)) {
throw new InvalidConfigurationException(
"Invalid toolchain configuration: feature '"
+ name
+ "', which is referenced from feature '"
+ reference
+ "', is not defined.");
}
return featuresByName.get(name);
}
public Optional<TRSRTransformation> apply(Optional<? extends IModelPart> part) {
if (part.isPresent()) {
if (part.get() instanceof MultiModelPart) {
MultiModelPart key = (MultiModelPart) part.get();
if (states.containsKey(key)) {
return Optional.of(
states
.get(key)
.apply(Optional.<IModelPart>absent())
.or(TRSRTransformation.identity()));
}
} else if (part.get() instanceof PartPart) {
PartPart partPart = (PartPart) part.get();
MultiModelPart key = new MultiModelPart(partPart.model, partPart.index);
if (states.containsKey(key)) {
return states.get(key).apply(partPart.part);
}
}
}
return Optional.absent();
}
/**
* Calls {@code expand} on the {@code consumer} for each expansion of the {@code consumer}'s
* used variable set.
*
* <p>The {@code consumer}'s used variable set must contain at most one variable of sequence
* type; additionally, all of the used variables must be available in the current variable
* configuration. If any of the preconditions are violated, throws an {@code
* ExpansionException}.
*/
void forEachExpansion(ExpansionConsumer consumer) {
Map<String, String> variableView = new HashMap<>();
String sequenceName = null;
for (String name : consumer.getUsedVariables()) {
if (sequenceVariables.containsKey(name)) {
if (variables.containsKey(name)) {
throw new ExpansionException(
"Internal error: variable '"
+ name
+ "' provided both as sequence and standard variable.");
} else if (sequenceName != null) {
throw new ExpansionException(
"Invalid toolchain configuration: trying to expand two variable list in one "
+ "flag group: '"
+ sequenceName
+ "' and '"
+ name
+ "'");
} else {
sequenceName = name;
}
} else if (variables.containsKey(name)) {
variableView.put(name, variables.get(name));
} else {
throw new ExpansionException(
"Invalid toolchain configuration: unknown variable '"
+ name
+ "' can not be expanded.");
}
}
if (sequenceName != null) {
for (String value : sequenceVariables.get(sequenceName)) {
variableView.put(sequenceName, value);
consumer.expand(variableView);
}
} else {
consumer.expand(variableView);
}
}
private String mathParse(String plainText) {
String parsedText = plainText;
if (!TextUtils.isEmpty(parsedText)) {
// Initialize replacement table.
initializeReplacementTable();
for (String operator : sOperators) {
if (sReplacementTable.containsKey(operator)) {
parsedText = parsedText.replace(operator, sReplacementTable.get(operator));
}
}
}
return parsedText;
}
private void markClassTrulyMutable(String className) {
if (trulyMutableClasses.contains(className)) {
return;
}
if (!allClasses.containsKey(className)) {
throw new RuntimeException("Tried to mark external class '" + className + "' truly mutable");
}
trulyMutableClasses.add(className);
madeProgress = true;
markClassAsHavingMutableDescendents(className);
}
@Override
public ModelFluid process(ImmutableMap<String, String> customData) {
if (!customData.containsKey("fluid")) return this;
String fluidStr = customData.get("fluid");
JsonElement e = new JsonParser().parse(fluidStr);
String fluid = e.getAsString();
if (!FluidRegistry.isFluidRegistered(fluid)) {
FMLLog.severe("fluid '%s' not found", fluid);
return WATER;
}
return new ModelFluid(FluidRegistry.getFluid(fluid));
}
private boolean superClassIsDefinitelyMutable(String superClassName) {
if (trulyMutableClasses.contains(superClassName)) {
return true;
}
if (EXTERNAL_IMMUTABLE_BASE_CLASSES.contains(superClassName)) {
return false;
}
if (!allClasses.containsKey(superClassName)) {
// All external classes are assumed to be mutable unless whitelisted.
return true;
}
// Assume internal classes are immutable until proven otherwise (in later rounds).
return false;
}
@RequiresNonNull("sessionAttributeUpdatedValueMap")
private void addMidRequestSessionAttributeDetail(Map<String, Object> detail) {
Map<String, /*@Nullable*/ Object> sessionAttributeInitialValuePlusMap = Maps.newHashMap();
sessionAttributeInitialValuePlusMap.putAll(sessionAttributeInitialValueMap);
// add empty values into initial values for any updated attributes that are not
// already present in initial values nested detail map
for (Entry<String, Optional<String>> entry : sessionAttributeUpdatedValueMap.entrySet()) {
if (!sessionAttributeInitialValueMap.containsKey(entry.getKey())) {
sessionAttributeInitialValuePlusMap.put(entry.getKey(), null);
}
}
detail.put(
"Session attributes (at beginning of this request)", sessionAttributeInitialValuePlusMap);
detail.put("Session attributes (updated during this request)", sessionAttributeUpdatedValueMap);
}
public static double pValue(final double chiSquare, final int degreesOfFreedom) {
checkArgument(
CHI_SQUARE_DISTRIBUTION.containsKey(degreesOfFreedom),
"degreesOfFreedom must be a key in CHI_SQUARE_DISTRIBUTION table");
final double[] chiSquares = CHI_SQUARE_DISTRIBUTION.get(degreesOfFreedom);
checkNotNull(chiSquares, "chiSquares");
for (int index = 0; index < chiSquares.length; index++) {
if (chiSquares[index] > chiSquare) {
return P_VALUES[index];
}
}
return P_VALUES[P_VALUES.length - 1];
}
/**
* Perform the merging and return the result.
*
* @return an instance of {@link com.android.manifmerger.MergingReport} that will give access to
* all the logging and merging records.
* <p>This method can be invoked several time and will re-do the file merges.
* @throws com.android.manifmerger.ManifestMerger2.MergeFailureException if the merging cannot
* be completed successfully.
*/
public MergingReport merge() throws MergeFailureException {
// provide some free placeholders values.
ImmutableMap<SystemProperty, Object> systemProperties = mSystemProperties.build();
if (systemProperties.containsKey(SystemProperty.PACKAGE)) {
mPlaceHolders.put(PACKAGE_NAME, systemProperties.get(SystemProperty.PACKAGE));
mPlaceHolders.put(APPLICATION_ID, systemProperties.get(SystemProperty.PACKAGE));
}
ManifestMerger2 manifestMerger =
new ManifestMerger2(
mLogger,
mMainManifestFile,
mLibraryFilesBuilder.build(),
mFlavorsAndBuildTypeFiles.build(),
mFeaturesBuilder.build(),
mPlaceHolders.build(),
new MapBasedKeyBasedValueResolver<SystemProperty>(systemProperties),
mMergeType,
Optional.fromNullable(mReportFile));
return manifestMerger.merge();
}
@Override
public String renderNodeXhtml(Node node) {
if (NodeUtils.isEmptyNode(node)) {
return "";
}
StringBuilder ret = new StringBuilder();
if (node.isParameter()) {
String lang = node.getParameter().trim();
if (langHash.containsKey(lang)) {
ret.append("<div class=\"code\"><pre class=\"")
.append(langHash.get(lang))
.append("\"><code>");
} else {
ret.append("<div class=\"code\"><pre class=\"no-highlight\"><code>");
}
} else {
ret.append("<div class=\"code\"><pre class=\"no-highlight\"><code>");
}
ret.append(node.renderChildrenXHtml());
ret.append("</code></pre></div>");
return ret.toString();
}
@Override
protected void masterOperation(
final TypesExistsRequest request,
final ClusterState state,
final ActionListener<TypesExistsResponse> listener)
throws ElasticSearchException {
String[] concreteIndices =
state.metaData().concreteIndices(request.indices(), request.ignoreIndices(), false);
if (concreteIndices.length == 0) {
listener.onResponse(new TypesExistsResponse(false));
return;
}
for (String concreteIndex : concreteIndices) {
if (!state.metaData().hasConcreteIndex(concreteIndex)) {
listener.onResponse(new TypesExistsResponse(false));
return;
}
ImmutableMap<String, MappingMetaData> mappings =
state.metaData().getIndices().get(concreteIndex).mappings();
if (mappings.isEmpty()) {
listener.onResponse(new TypesExistsResponse(false));
return;
}
for (String type : request.types()) {
if (!mappings.containsKey(type)) {
listener.onResponse(new TypesExistsResponse(false));
return;
}
}
}
listener.onResponse(new TypesExistsResponse(true));
}
public boolean has(String lang) {
return vals.containsKey(lang);
}
@Override
public String explain(ESQuery esQuery) {
return QUERY_RESULTS_MAP.containsKey(esQuery.getQuery()) ? "{}" : null;
}
public boolean nodeExists(String nodeId) {
return nodes.containsKey(nodeId);
}
public boolean hasMapping(String mappingType) {
return mappers.containsKey(mappingType);
}
protected String getAntPropertyName(String fieldName) {
if (FIELD_NAMES_TO_ANT_PROPERTIES.containsKey(fieldName)) {
return FIELD_NAMES_TO_ANT_PROPERTIES.get(fieldName);
}
return fieldName;
}
private void addCompoundSortField(
XContentParser parser, SearchContext context, List<SortField> sortFields) throws Exception {
XContentParser.Token token;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
String fieldName = parser.currentName();
boolean reverse = false;
String missing = null;
String innerJsonName = null;
boolean ignoreUnmapped = false;
SortMode sortMode = null;
Filter nestedFilter = null;
String nestedPath = null;
token = parser.nextToken();
if (token == XContentParser.Token.VALUE_STRING) {
String direction = parser.text();
if (direction.equals("asc")) {
reverse = SCORE_FIELD_NAME.equals(fieldName);
} else if (direction.equals("desc")) {
reverse = !SCORE_FIELD_NAME.equals(fieldName);
} else {
throw new ElasticSearchIllegalArgumentException(
"sort direction [" + fieldName + "] not supported");
}
addSortField(
context,
sortFields,
fieldName,
reverse,
ignoreUnmapped,
missing,
sortMode,
nestedPath,
nestedFilter);
} else {
if (parsers.containsKey(fieldName)) {
sortFields.add(parsers.get(fieldName).parse(parser, context));
} else {
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
innerJsonName = parser.currentName();
} else if (token.isValue()) {
if ("reverse".equals(innerJsonName)) {
reverse = parser.booleanValue();
} else if ("order".equals(innerJsonName)) {
if ("asc".equals(parser.text())) {
reverse = SCORE_FIELD_NAME.equals(fieldName);
} else if ("desc".equals(parser.text())) {
reverse = !SCORE_FIELD_NAME.equals(fieldName);
}
} else if ("missing".equals(innerJsonName)) {
missing = parser.textOrNull();
} else if ("ignore_unmapped".equals(innerJsonName)
|| "ignoreUnmapped".equals(innerJsonName)) {
ignoreUnmapped = parser.booleanValue();
} else if ("sort_mode".equals(innerJsonName)
|| "sortMode".equals(innerJsonName)
|| "mode".equals(innerJsonName)) {
sortMode = SortMode.fromString(parser.text());
} else if ("nested_path".equals(innerJsonName)
|| "nestedPath".equals(innerJsonName)) {
nestedPath = parser.text();
} else {
throw new ElasticSearchIllegalArgumentException(
"sort option [" + innerJsonName + "] not supported");
}
} else if (token == XContentParser.Token.START_OBJECT) {
if ("nested_filter".equals(innerJsonName) || "nestedFilter".equals(innerJsonName)) {
nestedFilter = context.queryParserService().parseInnerFilter(parser);
} else {
throw new ElasticSearchIllegalArgumentException(
"sort option [" + innerJsonName + "] not supported");
}
}
}
addSortField(
context,
sortFields,
fieldName,
reverse,
ignoreUnmapped,
missing,
sortMode,
nestedPath,
nestedFilter);
}
}
}
}
}
public boolean has(String param) {
return params.containsKey(param);
}
/**
* @param key
* @return true if the property exists.
*/
public boolean hasProperty(String key) {
if (updatedContent.containsKey(key)) {
return !(updatedContent.get(key) instanceof RemoveProperty);
}
return content.containsKey(key) && !(content.get(key) instanceof RemoveProperty);
}
/**
* Takes a map of directory fragments to root paths, and creates a symlink forest under an
* existing linkRoot to the corresponding source dirs or files. Symlink are made at the highest
* dir possible, linking files directly only when needed with nested packages.
*/
public static void plantLinkForest(ImmutableMap<PathFragment, Path> packageRootMap, Path linkRoot)
throws IOException {
Path emptyPackagePath = null;
// Create a sorted map of all dirs (packages and their ancestors) to sets of their roots.
// Packages come from exactly one root, but their shared ancestors may come from more.
// The map is maintained sorted lexicographically, so parents are before their children.
Map<PathFragment, Set<Path>> dirRootsMap = Maps.newTreeMap();
for (Map.Entry<PathFragment, Path> entry : packageRootMap.entrySet()) {
PathFragment pkgDir = entry.getKey();
Path pkgRoot = entry.getValue();
if (pkgDir.segmentCount() == 0) {
emptyPackagePath = entry.getValue();
}
for (int i = 1; i <= pkgDir.segmentCount(); i++) {
PathFragment dir = pkgDir.subFragment(0, i);
Set<Path> roots = dirRootsMap.get(dir);
if (roots == null) {
roots = Sets.newHashSet();
dirRootsMap.put(dir, roots);
}
roots.add(pkgRoot);
}
}
// Now add in roots for all non-pkg dirs that are in between two packages, and missed above.
for (Map.Entry<PathFragment, Set<Path>> entry : dirRootsMap.entrySet()) {
PathFragment dir = entry.getKey();
if (!packageRootMap.containsKey(dir)) {
PathFragment pkgDir = longestPathPrefix(dir, packageRootMap.keySet());
if (pkgDir != null) {
entry.getValue().add(packageRootMap.get(pkgDir));
}
}
}
// Create output dirs for all dirs that have more than one root and need to be split.
for (Map.Entry<PathFragment, Set<Path>> entry : dirRootsMap.entrySet()) {
PathFragment dir = entry.getKey();
if (entry.getValue().size() > 1) {
if (LOG_FINER) {
LOG.finer("mkdir " + linkRoot.getRelative(dir));
}
createDirectoryAndParents(linkRoot.getRelative(dir));
}
}
// Make dir links for single rooted dirs.
for (Map.Entry<PathFragment, Set<Path>> entry : dirRootsMap.entrySet()) {
PathFragment dir = entry.getKey();
Set<Path> roots = entry.getValue();
// Simple case of one root for this dir.
if (roots.size() == 1) {
if (dir.segmentCount() > 1 && dirRootsMap.get(dir.getParentDirectory()).size() == 1) {
continue; // skip--an ancestor will link this one in from above
}
// This is the top-most dir that can be linked to a single root. Make it so.
Path root = roots.iterator().next(); // lone root in set
if (LOG_FINER) {
LOG.finer("ln -s " + root.getRelative(dir) + " " + linkRoot.getRelative(dir));
}
linkRoot.getRelative(dir).createSymbolicLink(root.getRelative(dir));
}
}
// Make links for dirs within packages, skip parent-only dirs.
for (Map.Entry<PathFragment, Set<Path>> entry : dirRootsMap.entrySet()) {
PathFragment dir = entry.getKey();
if (entry.getValue().size() > 1) {
// If this dir is at or below a package dir, link in its contents.
PathFragment pkgDir = longestPathPrefix(dir, packageRootMap.keySet());
if (pkgDir != null) {
Path root = packageRootMap.get(pkgDir);
try {
Path absdir = root.getRelative(dir);
if (absdir.isDirectory()) {
if (LOG_FINER) {
LOG.finer("ln -s " + absdir + "/* " + linkRoot.getRelative(dir) + "/");
}
for (Path target : absdir.getDirectoryEntries()) {
PathFragment p = target.relativeTo(root);
if (!dirRootsMap.containsKey(p)) {
// LOG.finest("ln -s " + target + " " + linkRoot.getRelative(p));
linkRoot.getRelative(p).createSymbolicLink(target);
}
}
} else {
LOG.fine("Symlink planting skipping dir '" + absdir + "'");
}
} catch (IOException e) {
e.printStackTrace();
}
// Otherwise its just an otherwise empty common parent dir.
}
}
}
if (emptyPackagePath != null) {
// For the top-level directory, generate symlinks to everything in the directory instead of
// the directory itself.
for (Path target : emptyPackagePath.getDirectoryEntries()) {
String baseName = target.getBaseName();
// Create any links that don't exist yet and don't start with bazel-.
if (!baseName.startsWith(Constants.PRODUCT_NAME + "-")
&& !linkRoot.getRelative(baseName).exists()) {
linkRoot.getRelative(baseName).createSymbolicLink(target);
}
}
}
}
@Override
public boolean containsKey(@Nullable Object key) {
return delegate.containsKey(key);
}
