public SoySauceImpl create(
CompiledTemplates templates,
ImmutableMap<String, ? extends SoyFunction> soyFunctionMap,
ImmutableMap<String, ? extends SoyPrintDirective> printDirectives) {
// SoySauce has no need for SoyFunctions that are not SoyJavaFunctions
// (it generates Java source code implementing BuiltinFunctions).
// Filter them out.
ImmutableMap.Builder<String, SoyJavaFunction> soyJavaFunctions = ImmutableMap.builder();
for (Map.Entry<String, ? extends SoyFunction> entry : soyFunctionMap.entrySet()) {
SoyFunction function = entry.getValue();
if (function instanceof SoyJavaFunction) {
soyJavaFunctions.put(entry.getKey(), (SoyJavaFunction) function);
}
}
// SoySauce has no need for SoyPrintDirectives that are not SoyJavaPrintDirectives.
// Filter them out.
ImmutableMap.Builder<String, SoyJavaPrintDirective> soyJavaPrintDirectives =
ImmutableMap.builder();
for (Map.Entry<String, ? extends SoyPrintDirective> entry : printDirectives.entrySet()) {
SoyPrintDirective printDirective = entry.getValue();
if (printDirective instanceof SoyJavaPrintDirective) {
soyJavaPrintDirectives.put(entry.getKey(), (SoyJavaPrintDirective) printDirective);
}
}
return new SoySauceImpl(
templates,
apiCallScopeProvider,
converterProvider.get(),
soyJavaFunctions.build(),
soyJavaPrintDirectives.build());
}
/**
* In a {@link BuckConfig}, an alias can either refer to a fully-qualified build target, or an
* alias defined earlier in the {@code alias} section. The mapping produced by this method
* reflects the result of resolving all aliases as values in the {@code alias} section.
*/
private static ImmutableMap<String, BuildTarget> createAliasToBuildTargetMap(
ImmutableMap<String, String> rawAliasMap) {
// We use a LinkedHashMap rather than an ImmutableMap.Builder because we want both (1) order to
// be preserved, and (2) the ability to inspect the Map while building it up.
LinkedHashMap<String, BuildTarget> aliasToBuildTarget = Maps.newLinkedHashMap();
for (Map.Entry<String, String> aliasEntry : rawAliasMap.entrySet()) {
String alias = aliasEntry.getKey();
validateAliasName(alias);
// Determine whether the mapping is to a build target or to an alias.
String value = aliasEntry.getValue();
BuildTarget buildTarget;
if (isValidAliasName(value)) {
buildTarget = aliasToBuildTarget.get(value);
if (buildTarget == null) {
throw new HumanReadableException("No alias for: %s.", value);
}
} else {
// Here we parse the alias values with a BuildTargetParser to be strict. We could be looser
// and just grab everything between "//" and ":" and assume it's a valid base path.
buildTarget =
BuildTargetParser.INSTANCE.parse(value, BuildTargetPatternParser.fullyQualified());
}
aliasToBuildTarget.put(alias, buildTarget);
}
return ImmutableMap.copyOf(aliasToBuildTarget);
}
public ImmutableSet<CxxInferCapture> createInferCaptureBuildRules(
ImmutableMap<String, CxxSource> sources,
CxxInferTools inferTools,
CxxInferSourceFilter sourceFilter) {
ImmutableSet.Builder<CxxInferCapture> objects = ImmutableSet.builder();
for (Map.Entry<String, CxxSource> entry : sources.entrySet()) {
String name = entry.getKey();
CxxSource source = entry.getValue();
Preconditions.checkState(
CxxSourceTypes.isPreprocessableType(source.getType()),
"Only preprocessable source types are currently supported");
if (sourceFilter.isBlacklisted(source)) {
continue;
}
CxxInferCapture rule = requireInferCaptureBuildRule(name, source, inferTools);
objects.add(rule);
}
return objects.build();
}
Iterable<WhenHttpRequest> findWhensMatchingRequest(
ImmutableMap<String, RestxSpec> allSpecs, RestxRequest restxRequest) {
Collection<WhenHttpRequest> matchingRequestsSpecs = Lists.newArrayList();
for (Map.Entry<String, RestxSpec> spec : allSpecs.entrySet()) {
for (When when : spec.getValue().getWhens()) {
if (when instanceof WhenHttpRequest) {
WhenHttpRequest request = (WhenHttpRequest) when;
String requestPath = request.getPath();
if (!requestPath.startsWith("/")) {
requestPath = "/" + requestPath;
}
StdRequest stdRequest =
StdRequest.builder()
.setBaseUri("http://restx.io") // baseUri is required but we won't use it
.setHttpMethod(request.getMethod())
.setFullPath(requestPath)
.build();
if (restxRequest.getHttpMethod().equals(stdRequest.getHttpMethod())
&& restxRequest.getRestxPath().equals(stdRequest.getRestxPath())) {
MapDifference<String, ImmutableList<String>> difference =
Maps.difference(restxRequest.getQueryParams(), stdRequest.getQueryParams());
if (difference.entriesOnlyOnRight().isEmpty()
&& difference.entriesDiffering().isEmpty()) {
matchingRequestsSpecs.add(request);
break;
}
}
}
}
}
return matchingRequestsSpecs;
}
public void updateSettings(Settings settings) {
Map<String, Settings> groupSettings = settings.getGroups("threadpool");
if (groupSettings.isEmpty()) {
return;
}
for (Map.Entry<String, Settings> executor : defaultExecutorTypeSettings.entrySet()) {
Settings updatedSettings = groupSettings.get(executor.getKey());
if (updatedSettings == null) {
continue;
}
ExecutorHolder oldExecutorHolder = executors.get(executor.getKey());
ExecutorHolder newExecutorHolder =
rebuild(executor.getKey(), oldExecutorHolder, updatedSettings, executor.getValue());
if (!oldExecutorHolder.equals(newExecutorHolder)) {
executors =
newMapBuilder(executors).put(executor.getKey(), newExecutorHolder).immutableMap();
if (!oldExecutorHolder.executor.equals(newExecutorHolder.executor)
&& oldExecutorHolder.executor instanceof EsThreadPoolExecutor) {
retiredExecutors.add(oldExecutorHolder);
((EsThreadPoolExecutor) oldExecutorHolder.executor)
.shutdown(new ExecutorShutdownListener(oldExecutorHolder));
}
}
}
}
@Override
public int execute(ExecutionContext context) {
File inputDirectory = inputDirectoryPath.toFile();
Preconditions.checkState(
inputDirectory.exists() && inputDirectory.isDirectory(),
"%s must be a directory.",
inputDirectoryPath);
try {
ImmutableMap.Builder<File, ZipEntry> zipEntriesBuilder = ImmutableMap.builder();
addDirectoryToZipEntryList(inputDirectory, "", zipEntriesBuilder);
ImmutableMap<File, ZipEntry> zipEntries = zipEntriesBuilder.build();
if (!zipEntries.isEmpty()) {
try (CustomZipOutputStream outputStream =
ZipOutputStreams.newOutputStream(outputZipPath.toFile())) {
for (Map.Entry<File, ZipEntry> zipEntry : zipEntries.entrySet()) {
outputStream.putNextEntry(zipEntry.getValue());
ByteStreams.copy(Files.newInputStreamSupplier(zipEntry.getKey()), outputStream);
outputStream.closeEntry();
}
}
}
} catch (IOException e) {
e.printStackTrace(context.getStdErr());
return 1;
}
return 0;
}
private ImmutableMap<Path, Path> getExpandedSourcePaths(
ExecutionContext context, ImmutableMap<Path, Path> paths) throws IOException {
ProjectFilesystem projectFilesystem = context.getProjectFilesystem();
ImmutableMap.Builder<Path, Path> sources = ImmutableMap.builder();
for (ImmutableMap.Entry<Path, Path> ent : paths.entrySet()) {
if (ent.getValue().toString().endsWith(SRC_ZIP)) {
Path destinationDirectory = projectFilesystem.resolve(tempDir.resolve(ent.getKey()));
Files.createDirectories(destinationDirectory);
ImmutableList<Path> zipPaths =
Unzip.extractZipFile(
projectFilesystem.resolve(ent.getValue()),
destinationDirectory,
Unzip.ExistingFileMode.OVERWRITE);
for (Path path : zipPaths) {
Path modulePath = destinationDirectory.relativize(path);
sources.put(modulePath, path);
}
} else {
sources.put(ent.getKey(), ent.getValue());
}
}
return sources.build();
}
Iterable<String> filterSpecsByOperation(
ImmutableMap<String, RestxSpec> allSpecs, String httpMethod, String path) {
StdRestxRequestMatcher matcher = new StdRestxRequestMatcher(httpMethod, path);
Collection<String> specs = Lists.newArrayList();
for (Map.Entry<String, RestxSpec> spec : allSpecs.entrySet()) {
for (When when : spec.getValue().getWhens()) {
if (when instanceof WhenHttpRequest) {
WhenHttpRequest request = (WhenHttpRequest) when;
String requestPath = request.getPath();
if (!requestPath.startsWith("/")) {
requestPath = "/" + requestPath;
}
if (requestPath.indexOf("?") != -1) {
requestPath = requestPath.substring(0, requestPath.indexOf("?"));
}
Optional<? extends RestxRequestMatch> match =
matcher.match(request.getMethod(), requestPath);
if (match.isPresent()) {
specs.add(spec.getKey());
break;
}
}
}
}
return specs;
}
protected void onConfigurationChanged() {
ProcessManager manager = getProcessManager();
FabricService fabric = getFabricService();
if (manager != null && fabric != null) {
ImmutableMap<String, Installation> map = manager.listInstallationMap();
ImmutableSet<Map.Entry<String, Installation>> entries = map.entrySet();
for (Map.Entry<String, Installation> entry : entries) {
String id = entry.getKey();
Installation installation = entry.getValue();
try {
Container container = null;
try {
container = fabric.getContainer(id);
} catch (Exception e) {
LOG.debug("No container for id: " + id + ". " + e, e);
}
if (container != null && installation != null) {
ChildContainerController controllerForContainer = getControllerForContainer(container);
if (controllerForContainer instanceof ProcessManagerController) {
ProcessManagerController processManagerController =
(ProcessManagerController) controllerForContainer;
processManagerController.updateInstallation(container, installation);
}
}
} catch (Exception e) {
LOG.warn("Failed to get PID for process " + id + ". " + e, e);
}
}
}
}
/**
* 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);
}
@Override
public String toString() {
MoreObjects.ToStringHelper helper = MoreObjects.toStringHelper(this);
helper.add(CLASS, klass.getName());
for (Map.Entry<String, String> entry : options.entrySet())
helper.add(entry.getKey(), entry.getValue());
return helper.toString();
}
@Override
public String toDelimitedString(char delimiter) {
StringBuilder sb = new StringBuilder();
for (Map.Entry<String, String> entry : settings.entrySet()) {
sb.append(entry.getKey()).append("=").append(entry.getValue()).append(delimiter);
}
return sb.toString();
}
private ImmutableMap<PathFragment, Path> transformPackageRoots(
ImmutableMap<PackageIdentifier, Path> packageRoots) {
ImmutableMap.Builder<PathFragment, Path> builder = ImmutableMap.builder();
for (Map.Entry<PackageIdentifier, Path> entry : packageRoots.entrySet()) {
builder.put(entry.getKey().getPathFragment(), entry.getValue());
}
return builder.build();
}
public static List<Tuple<ColumnIdent, ReferenceInfo>> forTable(TableIdent tableIdent) {
List<Tuple<ColumnIdent, ReferenceInfo>> columns = new ArrayList<>(COLUMN_IDENTS.size());
for (Map.Entry<ColumnIdent, DataType> entry : COLUMN_IDENTS.entrySet()) {
columns.add(
new Tuple<>(entry.getKey(), newInfo(tableIdent, entry.getKey(), entry.getValue())));
}
return columns;
}
private @Nullable HttpService getHttpService(String path) throws Exception {
for (Entry<Pattern, HttpService> entry : httpServices.entrySet()) {
Matcher matcher = entry.getKey().matcher(path);
if (matcher.matches()) {
return entry.getValue();
}
}
return null;
}
SerializedForm(ImmutableMap<?, ?> map) {
keys = new Object[map.size()];
values = new Object[map.size()];
int i = 0;
for (Entry<?, ?> entry : map.entrySet()) {
keys[i] = entry.getKey();
values[i] = entry.getValue();
i++;
}
}
/**
* Try to guess the timezone code, and replace it with a timezone offset. Note: JodaTime can guess
* a few codes already, they didn't include all codes since they are not standardized. This method
* should only be used in last resort.
*
* @param date Formated date, supposedly ending with a timezone code
* @return Date with the code replaced by its offset if there is a match
*/
public static String guessTimezoneOffset(String date) {
for (Entry<String, String> entry : TIMEZONE_CODE_MAP.entrySet()) {
String code = entry.getKey();
String offset = entry.getValue();
String pattern = " \\(?" + code + "\\)?";
if (date.matches(".+" + pattern)) {
return date.replaceAll(pattern, offset);
}
}
return date;
}
/**
* Returns true if any of the options in {@code options} matches both of the regular expressions
* provided: its name matches the option's name and its value matches the option's value.
*/
public boolean optionMatches(String namePattern, String valuePattern) {
Matcher nameMatcher = Pattern.compile(namePattern).matcher("");
Matcher valueMatcher = Pattern.compile(valuePattern).matcher("");
for (Map.Entry<ProtoMember, Object> entry : map.entrySet()) {
if (nameMatcher.reset(entry.getKey().member()).matches()
&& valueMatcher.reset(String.valueOf(entry.getValue())).matches()) {
return true;
}
}
return false;
}
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();
}
@Override
public void writeTo(StreamOutput out) throws IOException {
out.writeUTF(nodeName);
out.writeUTF(nodeId);
addressToStream(out, address);
out.writeVInt(attributes.size());
for (Map.Entry<String, String> entry : attributes.entrySet()) {
out.writeUTF(entry.getKey());
out.writeUTF(entry.getValue());
}
Version.writeVersion(version, out);
}
public ImmutableSet<DependencyEntry> getDependencies(IjModule module) {
ImmutableMap<IjProjectElement, IjModuleGraph.DependencyType> deps =
moduleGraph.getDepsFor(module);
IjDependencyListBuilder dependencyListBuilder = new IjDependencyListBuilder();
for (Map.Entry<IjProjectElement, IjModuleGraph.DependencyType> entry : deps.entrySet()) {
IjProjectElement element = entry.getKey();
IjModuleGraph.DependencyType dependencyType = entry.getValue();
element.addAsDependency(dependencyType, dependencyListBuilder);
}
return dependencyListBuilder.build();
}
/**
* Return the manifest as a JSON blob to write to the pex processes stdin.
*
* <p>We use stdin rather than passing as an argument to the processes since manifest files can
* occasionally get extremely large, and surpass exec/shell limits on arguments.
*/
@Override
protected Optional<String> getStdin(ExecutionContext context) {
// Convert the map of paths to a map of strings before converting to JSON.
ImmutableMap<Path, Path> resolvedModules;
try {
resolvedModules = getExpandedSourcePaths(context, modules);
} catch (IOException e) {
throw new RuntimeException(e);
}
ImmutableMap.Builder<String, String> modulesBuilder = ImmutableMap.builder();
for (ImmutableMap.Entry<Path, Path> ent : resolvedModules.entrySet()) {
modulesBuilder.put(ent.getKey().toString(), ent.getValue().toString());
}
ImmutableMap.Builder<String, String> resourcesBuilder = ImmutableMap.builder();
for (ImmutableMap.Entry<Path, Path> ent : resources.entrySet()) {
resourcesBuilder.put(ent.getKey().toString(), ent.getValue().toString());
}
ImmutableMap.Builder<String, String> nativeLibrariesBuilder = ImmutableMap.builder();
for (ImmutableMap.Entry<Path, Path> ent : nativeLibraries.entrySet()) {
nativeLibrariesBuilder.put(ent.getKey().toString(), ent.getValue().toString());
}
ImmutableList.Builder<String> prebuiltLibrariesBuilder = ImmutableList.builder();
for (Path req : prebuiltLibraries) {
prebuiltLibrariesBuilder.add(req.toString());
}
try {
return Optional.of(
context
.getObjectMapper()
.writeValueAsString(
ImmutableMap.of(
"modules", modulesBuilder.build(),
"resources", resourcesBuilder.build(),
"nativeLibraries", nativeLibrariesBuilder.build(),
"prebuiltLibraries", prebuiltLibrariesBuilder.build())));
} catch (IOException e) {
throw Throwables.propagate(e);
}
}
/**
* Collects and returns all the Java objects reachable in Skylark from (and including)
* firstClassObject with the corresponding SkylarkSignature annotations.
*
* <p>Note that the {@link SkylarkSignature} annotation for firstClassObject - firstAnnotation -
* is also an input parameter, because some top level Skylark built-in objects and methods are not
* annotated on the class, but on a field referencing them.
*/
void collect(
SkylarkModule firstModule, Class<?> firstClass, Map<String, SkylarkModuleDoc> modules) {
Set<Class<?>> processedClasses = new HashSet<>();
LinkedList<Class<?>> classesToProcess = new LinkedList<>();
Map<Class<?>, SkylarkModule> annotations = new HashMap<>();
classesToProcess.addLast(firstClass);
annotations.put(firstClass, firstModule);
while (!classesToProcess.isEmpty()) {
Class<?> classObject = classesToProcess.removeFirst();
SkylarkModule annotation = annotations.get(classObject);
processedClasses.add(classObject);
if (!modules.containsKey(annotation.name())) {
modules.put(annotation.name(), new SkylarkModuleDoc(annotation, classObject));
}
SkylarkModuleDoc module = modules.get(annotation.name());
if (module.javaMethodsNotCollected()) {
ImmutableMap<Method, SkylarkCallable> methods =
FuncallExpression.collectSkylarkMethodsWithAnnotation(classObject);
ArrayList<SkylarkJavaMethod> methodList = new ArrayList<>();
for (Map.Entry<Method, SkylarkCallable> entry : methods.entrySet()) {
methodList.add(new SkylarkJavaMethod(entry.getKey(), entry.getValue()));
}
module.setJavaMethods(methodList);
for (Map.Entry<Method, SkylarkCallable> method : methods.entrySet()) {
Class<?> returnClass = method.getKey().getReturnType();
if (returnClass.isAnnotationPresent(SkylarkModule.class)
&& !processedClasses.contains(returnClass)) {
classesToProcess.addLast(returnClass);
annotations.put(returnClass, returnClass.getAnnotation(SkylarkModule.class));
}
}
}
}
}
/**
* Resolve the map of name to {@link SourcePath} to a map of full header name to {@link
* SourcePath}.
*/
public static ImmutableMap<Path, SourcePath> resolveHeaderMap(
Path basePath, ImmutableMap<String, SourcePath> headers) {
ImmutableMap.Builder<Path, SourcePath> headerMap = ImmutableMap.builder();
// Resolve the "names" of the headers to actual paths by prepending the base path
// specified by the build target.
for (ImmutableMap.Entry<String, SourcePath> ent : headers.entrySet()) {
Path path = basePath.resolve(ent.getKey());
headerMap.put(path, ent.getValue());
}
return headerMap.build();
}
public Set<String> simpleMatchToIndexNames(String pattern) {
int dotIndex = pattern.indexOf('.');
if (dotIndex != -1) {
String possibleType = pattern.substring(0, dotIndex);
DocumentMapper possibleDocMapper = mappers.get(possibleType);
if (possibleDocMapper != null) {
Set<String> typedFields = Sets.newHashSet();
for (String indexName : possibleDocMapper.mappers().simpleMatchToIndexNames(pattern)) {
typedFields.add(possibleType + "." + indexName);
}
return typedFields;
}
}
Set<String> fields = Sets.newHashSet();
for (Map.Entry<String, FieldMappers> entry : fullNameFieldMappers.entrySet()) {
if (Regex.simpleMatch(pattern, entry.getKey())) {
for (FieldMapper mapper : entry.getValue()) {
fields.add(mapper.names().indexName());
}
}
}
for (Map.Entry<String, FieldMappers> entry : indexNameFieldMappers.entrySet()) {
if (Regex.simpleMatch(pattern, entry.getKey())) {
for (FieldMapper mapper : entry.getValue()) {
fields.add(mapper.names().indexName());
}
}
}
for (Map.Entry<String, FieldMappers> entry : nameFieldMappers.entrySet()) {
if (Regex.simpleMatch(pattern, entry.getKey())) {
for (FieldMapper mapper : entry.getValue()) {
fields.add(mapper.names().indexName());
}
}
}
return fields;
}
private void installFiles(
String filesType,
ImmutableMap<String, Path> filesToInstallByHash,
String metadataFileContents,
String filenameFormat,
Path destinationDirRelativeToDataRoot)
throws Exception {
try (TraceEventLogger ignored1 =
TraceEventLogger.start(eventBus, "multi_install_" + filesType)) {
device.createForward(agentPort, agentPort);
try {
for (Map.Entry<String, Path> entry : filesToInstallByHash.entrySet()) {
Path destination =
destinationDirRelativeToDataRoot.resolve(
String.format(filenameFormat, entry.getKey()));
Path source = entry.getValue();
try (TraceEventLogger ignored2 =
TraceEventLogger.start(eventBus, "install_" + filesType)) {
installFile(device, agentPort, destination, source);
}
}
try (TraceEventLogger ignored3 =
TraceEventLogger.start(eventBus, "install_" + filesType + "_metadata")) {
try (NamedTemporaryFile temp = new NamedTemporaryFile("metadata", "tmp")) {
com.google.common.io.Files.write(
metadataFileContents.getBytes(Charsets.UTF_8), temp.get().toFile());
installFile(
device,
agentPort,
destinationDirRelativeToDataRoot.resolve("metadata.txt"),
temp.get());
}
}
} finally {
try {
device.removeForward(agentPort, agentPort);
} catch (AdbCommandRejectedException e) {
LOG.warn(e, "Failed to remove adb forward on port %d for device %s", agentPort, device);
eventBus.post(
ConsoleEvent.warning(
"Failed to remove adb forward %d. This is not necessarily a problem\n"
+ "because it will be recreated during the next exopackage installation.\n"
+ "See the log for the full exception.",
agentPort));
}
}
}
}
@PostConstruct
public void init() {
final ImmutableMap<String, AppManifest> initialTenantMap = tenantConfig.tenantMap();
log.debug(
"Registering {} subscribers for {} tenants: {}",
getClass().getName(),
initialTenantMap.size(),
initialTenantMap.keySet());
for (final Map.Entry<String, AppManifest> tenant : initialTenantMap.entrySet()) {
createSubscribers(tenant.getKey(), tenant.getValue(), "Init");
}
if (tenantRepo != null) {
tenantRepo.addListener(this);
}
}
public Iterable<String> listStreams() {
final Set<String> streams = Sets.newHashSet();
for (Entry<String, Object> e : content.entrySet()) {
String k = e.getKey();
String[] streamIds = StringUtils.split(k, "/", 2);
if (streamIds.length == 2) {
streams.add(streamIds[1]);
}
}
return new Iterable<String>() {
public Iterator<String> iterator() {
return streams.iterator();
}
};
}
/**
* Similar to {@link #createZip(Collection, Path)}, but also takes a list of additional files to
* write in the zip, including their contents, as a map. It's assumed only paths that should not
* be ignored are passed to this method.
*/
public void createZip(
Collection<Path> pathsToIncludeInZip,
Path out,
ImmutableMap<Path, String> additionalFileContents)
throws IOException {
try (CustomZipOutputStream zip = ZipOutputStreams.newOutputStream(out)) {
for (Path path : pathsToIncludeInZip) {
boolean isDirectory = isDirectory(path);
String entryName = path.toString();
if (isDirectory) {
entryName += "/";
}
CustomZipEntry entry = new CustomZipEntry(entryName);
// We want deterministic ZIPs, so avoid mtimes.
entry.setTime(0);
// Support executable files. If we detect this file is executable, store this
// information as 0100 in the field typically used in zip implementations for
// POSIX file permissions. We'll use this information when unzipping.
if (isExecutable(path)) {
entry.setExternalAttributes(
MorePosixFilePermissions.toMode(EnumSet.of(PosixFilePermission.OWNER_EXECUTE)) << 16);
}
zip.putNextEntry(entry);
if (!isDirectory) {
try (InputStream input = newFileInputStream(path)) {
ByteStreams.copy(input, zip);
}
}
zip.closeEntry();
}
for (Map.Entry<Path, String> fileContentsEntry : additionalFileContents.entrySet()) {
CustomZipEntry entry = new CustomZipEntry(fileContentsEntry.getKey().toString());
// We want deterministic ZIPs, so avoid mtimes.
entry.setTime(0);
zip.putNextEntry(entry);
try (InputStream stream =
new ByteArrayInputStream(fileContentsEntry.getValue().getBytes(Charsets.UTF_8))) {
ByteStreams.copy(stream, zip);
}
zip.closeEntry();
}
}
}
public HBaseStoreManager(org.apache.commons.configuration.Configuration config)
throws StorageException {
super(config, PORT_DEFAULT);
this.tableName = config.getString(TABLE_NAME_KEY, TABLE_NAME_DEFAULT);
this.hconf = HBaseConfiguration.create();
for (Map.Entry<String, String> confEntry : HBASE_CONFIGURATION.entrySet()) {
if (config.containsKey(confEntry.getKey())) {
hconf.set(confEntry.getValue(), config.getString(confEntry.getKey()));
}
}
// Copy a subset of our commons config into a Hadoop config
org.apache.commons.configuration.Configuration hbCommons =
config.subset(HBASE_CONFIGURATION_NAMESPACE);
@SuppressWarnings("unchecked") // I hope commons-config eventually fixes this
Iterator<String> keys = hbCommons.getKeys();
int keysLoaded = 0;
while (keys.hasNext()) {
String key = keys.next();
String value = hbCommons.getString(key);
logger.debug("HBase configuration: setting {}={}", key, value);
hconf.set(key, value);
keysLoaded++;
}
logger.debug("HBase configuration: set a total of {} configuration values", keysLoaded);
connectionPool = new HTablePool(hconf, connectionPoolSize);
openStores = new ConcurrentHashMap<String, HBaseKeyColumnValueStore>();
// TODO: allowing publicly mutate fields is bad, should be fixed
features = new StoreFeatures();
features.supportsScan = true;
features.supportsBatchMutation = true;
features.supportsTransactions = false;
features.supportsConsistentKeyOperations = true;
features.supportsLocking = false;
features.isKeyOrdered = false;
features.isDistributed = true;
features.hasLocalKeyPartition = false;
}
