NominalType(ImmutableMap<String, JSType> typeMap, RawNominalType rawType) {
Preconditions.checkState(
typeMap.isEmpty()
|| typeMap.keySet().containsAll(rawType.getTypeParameters())
&& rawType.getTypeParameters().containsAll(typeMap.keySet()));
this.typeMap = typeMap;
this.rawType = rawType;
}
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);
}
public static String dumpConfigurationAsJson() {
ImmutableCollection<String> keys = CONFIGURATION_SECTIONS.keySet();
ObjectMapper mapper = new ObjectMapper();
JsonFactory jfactory = mapper.getJsonFactory();
StringWriter sw = new StringWriter();
try {
JsonGenerator gen = jfactory.createJsonGenerator(sw);
gen.writeStartArray();
for (String v : keys) {
String st = dumpConfigurationAsJson(v);
ObjectMapper op = new ObjectMapper();
JsonNode p = op.readTree(st);
Logger.debug("OBJECT:" + p.toString());
Logger.debug("STRING:" + st);
// JsonParser jp = jfactory.createJsonParser(st);
gen.writeTree(p);
}
gen.writeEndArray();
gen.close();
return sw.toString();
} catch (Exception e) {
Logger.error("Cannot generate a json for the configuration", e);
}
return "[]";
} // dumpConfigurationAsJson()
@Override
public String errorMessage(String name) {
String suffix =
"Available attributes: "
+ Joiner.on(", ").join(Ordering.natural().sortedCopy(values.keySet()));
return String.format(errorMessage, name) + "\n" + suffix;
}
public void testHashing() {
for (String stringToTest : INPUTS) {
for (String algorithmToTest : ALGORITHMS.keySet()) {
assertMessageDigestHashing(HashTestUtils.ascii(stringToTest), algorithmToTest);
}
}
}
public static AnyRequest parse(final String originalTarget) throws MalformedRequestException {
final Matcher matcher = DOCUMENT_PATTERN.matcher(originalTarget);
if (matcher.find() && matcher.groupCount() >= 4) {
// Document source name plus extension, minus page identifier.
final String fullTarget = matcher.group(2) + "." + matcher.group(4);
final boolean showProblems = fullTarget.endsWith(ERRORPAGE_SUFFIX);
final String targetMinusError;
if (showProblems) {
targetMinusError = fullTarget.substring(0, fullTarget.length() - ERRORPAGE_SUFFIX.length());
} else {
targetMinusError = fullTarget;
}
final String rawDocumentMimeType = extractExtension(targetMinusError);
final String rawDocumentSourceName =
targetMinusError.substring(
0, targetMinusError.length() - rawDocumentMimeType.length() - 1);
final String maybePageIdentifier = matcher.group(3);
final PageIdentifier pageIdentifier =
maybePageIdentifier == null ? null : new PageIdentifier(maybePageIdentifier);
final RenditionMimeType renditionMimeType =
RenditionMimeType.maybeValueOf(
rawDocumentMimeType == null ? null : rawDocumentMimeType.toUpperCase());
final ImmutableMap<String, String> parameterMap =
matcher.groupCount() >= 5
? getQueryMap(matcher.group(5))
: ImmutableMap.<String, String>of();
verifyAllParameterNames(parameterMap.keySet());
final ResourceName alternateStylesheet = extractResourceName(parameterMap);
final ImmutableSet<Tag> tagset = extractTags(parameterMap);
final AnyRequest request;
if (renditionMimeType == null) {
request = new GenericRequest(originalTarget, rawDocumentSourceName, rawDocumentMimeType);
} else {
request =
new GenericRequest(
originalTarget,
rawDocumentSourceName,
showProblems,
renditionMimeType,
pageIdentifier,
alternateStylesheet,
tagset);
}
return request;
} else {
throw new MalformedRequestException("Could not parse: '" + originalTarget + "'.");
}
}
public static String dumpConfiguration() {
ImmutableCollection<String> keys = CONFIGURATION_SECTIONS.keySet();
StringBuilder sb = new StringBuilder();
for (String v : keys) {
sb.append(dumpConfiguration(v));
sb.append("\n");
}
return sb.toString();
} // dumpConfiguration()
public static Iterable<? extends XcodeprojBuildSetting> defaultWarningsForXcode() {
return Iterables.transform(
DEFAULT_WARNINGS.keySet(),
new Function<String, XcodeprojBuildSetting>() {
@Override
public XcodeprojBuildSetting apply(String key) {
return XcodeprojBuildSetting.newBuilder().setName(key).setValue("YES").build();
}
});
}
// -------------------------------------------------------------------------
public void test_cashFlowEquivalentAndSensitivity() {
Swap swap = Swap.builder().legs(IBOR_LEG, FIXED_LEG).build();
ImmutableMap<NotionalExchange, PointSensitivityBuilder> computedFull =
CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivitySwap(swap.expand(), PROVIDER);
ImmutableList<NotionalExchange> keyComputedFull = computedFull.keySet().asList();
ImmutableList<PointSensitivityBuilder> valueComputedFull = computedFull.values().asList();
ImmutableMap<NotionalExchange, PointSensitivityBuilder> computedIborLeg =
CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityIborLeg(
IBOR_LEG.expand(), PROVIDER);
ImmutableMap<NotionalExchange, PointSensitivityBuilder> computedFixedLeg =
CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityFixedLeg(
FIXED_LEG.expand(), PROVIDER);
assertEquals(computedFixedLeg.keySet().asList(), keyComputedFull.subList(0, 2));
assertEquals(computedIborLeg.keySet().asList(), keyComputedFull.subList(2, 6));
assertEquals(computedFixedLeg.values().asList(), valueComputedFull.subList(0, 2));
assertEquals(computedIborLeg.values().asList(), valueComputedFull.subList(2, 6));
double eps = 1.0e-7;
RatesFiniteDifferenceSensitivityCalculator calc =
new RatesFiniteDifferenceSensitivityCalculator(eps);
int size = keyComputedFull.size();
for (int i = 0; i < size; ++i) {
final int index = i;
CurveCurrencyParameterSensitivities expected =
calc.sensitivity(
PROVIDER,
p ->
((NotionalExchange)
CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap.expand(), p)
.getPaymentEvents()
.get(index))
.getPaymentAmount());
PointSensitivityBuilder point =
computedFull.get(
CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap.expand(), PROVIDER)
.getPaymentEvents()
.get(index));
CurveCurrencyParameterSensitivities computed =
PROVIDER.curveParameterSensitivity(point.build());
assertTrue(computed.equalWithTolerance(expected, eps * NOTIONAL));
}
}
private void installNativeLibraryFiles() throws Exception {
ImmutableMultimap<String, Path> allLibraries = getAllLibraries();
ImmutableSet.Builder<String> providedLibraries = ImmutableSet.builder();
for (String abi : getDeviceAbis()) {
ImmutableMap<String, Path> libraries =
getRequiredLibrariesForAbi(allLibraries, abi, providedLibraries.build());
installNativeLibrariesForAbi(abi, libraries);
providedLibraries.addAll(libraries.keySet());
}
}
public ImmutableMap<IjLibrary, DependencyType> getDependentLibrariesFor(IjModule source) {
final ImmutableMap<IjProjectElement, DependencyType> deps = getDepsFor(source);
return FluentIterable.from(deps.keySet())
.filter(IjLibrary.class)
.toMap(
new Function<IjLibrary, DependencyType>() {
@Override
public DependencyType apply(IjLibrary input) {
return Preconditions.checkNotNull(deps.get(input));
}
});
}
public void renameFile(String from, String to) throws IOException {
synchronized (mutex) {
StoreFileMetaData fromMetaData = filesMetadata.get(from); // we should always find this one
if (fromMetaData == null) {
throw new FileNotFoundException(from);
}
directoryService.renameFile(fromMetaData.directory(), from, to);
StoreFileMetaData toMetaData =
new StoreFileMetaData(
to, fromMetaData.length(), fromMetaData.checksum(), fromMetaData.directory());
filesMetadata =
MapBuilder.newMapBuilder(filesMetadata).remove(from).put(to, toMetaData).immutableMap();
files = filesMetadata.keySet().toArray(new String[filesMetadata.size()]);
}
}
@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);
}
}
private boolean classIsDefinitelyMutable(ClassNode klass) {
if (superClassIsDefinitelyMutable(klass.superName)) {
log.add("Mutable parent: " + klass.name + " < " + klass.superName);
return true;
}
for (FieldNode field : klass.fields) {
if ((field.access & Opcodes.ACC_STATIC) != 0) {
continue;
}
if ((field.access & Opcodes.ACC_FINAL) == 0) {
log.add("Non-final field: " + klass.name + "#" + field.name + ":" + field.desc);
return true;
}
if (field.name.contains("$")) {
// Generated fields are assumed to be effectively immutable.
// This could, in principle, miss an issue like a static reference to a
// seemingly-immutable inner class object that maintains a hidden reference
// to its mutable outer object, but that seems unlikely.
continue;
}
Type type = Type.getType(field.desc);
if (IMMUTABLE_TYPE_SORTS.contains(type.getSort())) {
continue;
}
if (type.getSort() != Type.OBJECT) {
log.add("Odd sort: " + klass.name + "#" + field.name + ":" + field.desc);
return true;
}
if (allClasses.keySet().contains(type.getInternalName())) {
if (classesWithMutableDescendents.contains(type.getInternalName())) {
log.add("Internal mutable field: " + klass.name + "#" + field.name + ":" + field.desc);
return true;
}
} else {
if (!EXTERNAL_IMMUTABLE_CLASSES.contains(type.getInternalName())) {
log.add("External mutable field: " + klass.name + "#" + field.name + ":" + field.desc);
return true;
}
}
}
return false;
}
private void go() {
while (true) {
madeProgress = false;
for (ClassNode klass : allClasses.values()) {
analyzeClass(klass);
}
if (!madeProgress) {
break;
}
}
immutableClasses =
ImmutableSet.copyOf(
Sets.difference(
allClasses.keySet(),
Sets.union(trulyMutableClasses, classesWithMutableDescendents)));
}
@Override
public com.google.common.base.Optional<Model> modelFor(ModelContext modelContext) {
ResolvedType propertiesHost = modelContext.alternateFor(modelContext.resolvedType(resolver));
if (isContainerType(propertiesHost)
|| isMapType(propertiesHost)
|| propertiesHost.getErasedType().isEnum()
|| isBaseType(Types.typeNameFor(propertiesHost.getErasedType()))
|| modelContext.hasSeenBefore(propertiesHost)) {
LOG.debug(
"Skipping model of type {} as its either a container type, map, enum or base type, or its already "
+ "been handled",
resolvedTypeSignature(propertiesHost).or("<null>"));
return Optional.absent();
}
ImmutableMap<String, ModelProperty> propertiesIndex =
uniqueIndex(properties(modelContext, propertiesHost), byPropertyName());
LOG.debug(
"Inferred {} properties. Properties found {}",
propertiesIndex.size(),
Joiner.on(", ").join(propertiesIndex.keySet()));
SortedSet<Map.Entry<String, ModelProperty>> sortedProperties =
new TreeSet<Map.Entry<String, ModelProperty>>(
new Comparator<Map.Entry<String, ModelProperty>>() {
@Override
public int compare(
Map.Entry<String, ModelProperty> e1, Map.Entry<String, ModelProperty> e2) {
if ((e1.getValue().getPosition().compareTo(e2.getValue().getPosition()) == 0)) {
return e1.getValue().getName().compareTo(e2.getValue().getName());
}
return new Integer(e1.getValue().getPosition())
.compareTo(e2.getValue().getPosition());
}
});
sortedProperties.addAll(propertiesIndex.entrySet());
Map<String, ModelProperty> properties = new LinkedHashMap<String, ModelProperty>();
// Map<String, ModelProperty> properties = newTreeMap();
// properties.putAll(propertiesIndex);
for (Map.Entry<String, ModelProperty> value : sortedProperties) {
properties.put(value.getKey(), value.getValue());
}
return Optional.of(modelBuilder(propertiesHost, properties, modelContext));
}
NominalType instantiateGenerics(Map<String, JSType> newTypeMap) {
if (newTypeMap.isEmpty()) {
return this;
}
if (!this.rawType.isGeneric()) {
return this.rawType.getAsNominalType();
}
ImmutableMap.Builder<String, JSType> builder = ImmutableMap.builder();
ImmutableMap<String, JSType> resultMap;
if (!typeMap.isEmpty()) {
// This branch is entered when a generic type appears "instantiated"
// in some other type, and now we're actually instantiating it to concrete
// types rather than to type variables, eg, here we instantiate Array's T to U,
// and when we call f, we instantiate U to boolean.
// /**
// * @template U
// * @param {!Array<U>} x
// */
// function f(x) { return x[0]; }
// f([true, false]);
for (String oldKey : typeMap.keySet()) {
builder.put(oldKey, typeMap.get(oldKey).substituteGenerics(newTypeMap));
}
resultMap = builder.build();
} else {
ImmutableList<String> typeParams = this.rawType.getTypeParameters();
for (String newKey : typeParams) {
if (newTypeMap.containsKey(newKey)) {
builder.put(newKey, newTypeMap.get(newKey));
}
}
resultMap = builder.build();
if (resultMap.isEmpty()) {
return this;
}
// This works around a bug in FunctionType, because we can't know where
// FunctionType#receiverType is coming from.
// If the condition is true, receiverType comes from a method declaration,
// and we should not create a new type here.
if (resultMap.size() < typeParams.size()) {
return this;
}
}
return new NominalType(resultMap, this.rawType);
}
/**
* Convert the object to string using Skylark syntax. The output tries to be reversible (but
* there is no guarantee, it depends on the actual values).
*/
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
boolean first = true;
builder.append("struct(");
// Sort by key to ensure deterministic output.
for (String key : Ordering.natural().sortedCopy(values.keySet())) {
if (!first) {
builder.append(", ");
}
first = false;
builder.append(key);
builder.append(" = ");
Printer.write(builder, values.get(key));
}
builder.append(")");
return builder.toString();
}
@Test
public void integrationTestMetaData2() {
DataServiceImpl dataServiceImpl = Mockito.mock(DataServiceImpl.class);
MetaDataServiceImpl metaDataService = new MetaDataServiceImpl(dataServiceImpl);
DefaultEntityMetaData newEntityMetaData = new DefaultEntityMetaData("attributes");
newEntityMetaData.addAttribute("ID");
List<String> skipEntities = Lists.<String>newArrayList("attributes");
String defaultPackage = "base";
ImmutableMap<String, EntityMetaData> newEntitiesMetaDataMap = Mockito.mock(ImmutableMap.class);
when(newEntitiesMetaDataMap.get("attributes")).thenReturn(newEntityMetaData);
when(newEntitiesMetaDataMap.keySet()).thenReturn(ImmutableSet.of("attributes"));
LinkedHashMap<String, Boolean> entitiesImportable = new LinkedHashMap<String, Boolean>();
entitiesImportable.put("attributes", true);
assertEquals(
metaDataService.integrationTestMetaData(
newEntitiesMetaDataMap, skipEntities, defaultPackage),
entitiesImportable);
}
@Override
public Optional<ImmutableWorkerInfo> findWorkerForTask(
final WorkerTaskRunnerConfig config,
final ImmutableMap<String, ImmutableWorkerInfo> zkWorkers,
final Task task) {
// don't run other datasources on affinity workers; we only want our configured datasources to
// run on them
ImmutableMap.Builder<String, ImmutableWorkerInfo> builder = new ImmutableMap.Builder<>();
for (String workerHost : zkWorkers.keySet()) {
if (!affinityWorkerHosts.contains(workerHost)) {
builder.put(workerHost, zkWorkers.get(workerHost));
}
}
ImmutableMap<String, ImmutableWorkerInfo> eligibleWorkers = builder.build();
List<String> workerHosts = affinityConfig.getAffinity().get(task.getDataSource());
if (workerHosts == null) {
return super.findWorkerForTask(config, eligibleWorkers, task);
}
ImmutableMap.Builder<String, ImmutableWorkerInfo> affinityBuilder =
new ImmutableMap.Builder<>();
for (String workerHost : workerHosts) {
ImmutableWorkerInfo zkWorker = zkWorkers.get(workerHost);
if (zkWorker != null) {
affinityBuilder.put(workerHost, zkWorker);
}
}
ImmutableMap<String, ImmutableWorkerInfo> affinityWorkers = affinityBuilder.build();
if (!affinityWorkers.isEmpty()) {
Optional<ImmutableWorkerInfo> retVal = super.findWorkerForTask(config, affinityWorkers, task);
if (retVal.isPresent()) {
return retVal;
}
}
return super.findWorkerForTask(config, eligibleWorkers, task);
}
@Override
public Map<String, Settings> getGroups(String settingPrefix) throws SettingsException {
if (settingPrefix.charAt(settingPrefix.length() - 1) != '.') {
settingPrefix = settingPrefix + ".";
}
// we don't really care that it might happen twice
Map<String, Map<String, String>> map = new LinkedHashMap<String, Map<String, String>>();
for (Object o : settings.keySet()) {
String setting = (String) o;
if (setting.startsWith(settingPrefix)) {
String nameValue = setting.substring(settingPrefix.length());
int dotIndex = nameValue.indexOf('.');
if (dotIndex == -1) {
throw new SettingsException(
"Failed to get setting group for ["
+ settingPrefix
+ "] setting prefix and setting ["
+ setting
+ "] because of a missing '.'");
}
String name = nameValue.substring(0, dotIndex);
String value = nameValue.substring(dotIndex + 1);
Map<String, String> groupSettings = map.get(name);
if (groupSettings == null) {
groupSettings = new LinkedHashMap<String, String>();
map.put(name, groupSettings);
}
groupSettings.put(value, get(setting));
}
}
Map<String, Settings> retVal = new LinkedHashMap<String, Settings>();
for (Map.Entry<String, Map<String, String>> entry : map.entrySet()) {
retVal.put(
entry.getKey(),
new ImmutableSettings(Collections.unmodifiableMap(entry.getValue()), classLoader));
}
return Collections.unmodifiableMap(retVal);
}
/**
* This test validates that the md5sum() method returns hashes that match the official test
* vectors specified in RFC 1321, The MD5 Message-Digest Algorithm.
*
* @throws Exception
*/
@Test
public void testValidateMd5Sum() throws Exception {
ImmutableMap<String, String> testVectors =
ImmutableMap.<String, String>builder()
.put("", "d41d8cd98f00b204e9800998ecf8427e")
.put("a", "0cc175b9c0f1b6a831c399e269772661")
.put("abc", "900150983cd24fb0d6963f7d28e17f72")
.put("message digest", "f96b697d7cb7938d525a2f31aaf161d0")
.put("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b")
.put(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
"d174ab98d277d9f5a5611c2c9f419d9f")
.put(
"12345678901234567890123456789012345678901234567890123456789012345678901234567890",
"57edf4a22be3c955ac49da2e2107b67a")
.build();
for (String testInput : testVectors.keySet()) {
FileSystemUtils.writeContentAsLatin1(testFile, testInput);
HashCode result = NativePosixFiles.md5sum(testFile.getPathString());
assertThat(testVectors).containsEntry(testInput, result.toString());
}
}
private void installNativeLibrariesForAbi(String abi, ImmutableMap<String, Path> libraries)
throws Exception {
if (libraries.isEmpty()) {
return;
}
ImmutableSet<String> requiredHashes = libraries.keySet();
ImmutableSet<String> presentHashes = prepareNativeLibsDir(abi, requiredHashes);
Map<String, Path> filesToInstallByHash =
Maps.filterKeys(libraries, Predicates.not(Predicates.in(presentHashes)));
String metadataContents =
Joiner.on('\n')
.join(
FluentIterable.from(libraries.entrySet())
.transform(
new Function<Map.Entry<String, Path>, String>() {
@Override
public String apply(Map.Entry<String, Path> input) {
String hash = input.getKey();
String filename = input.getValue().getFileName().toString();
int index = filename.indexOf('.');
String libname =
index == -1 ? filename : filename.substring(0, index);
return String.format("%s native-%s.so", libname, hash);
}
}));
installFiles(
"native_library",
ImmutableMap.copyOf(filesToInstallByHash),
metadataContents,
"native-%s.so",
NATIVE_LIBS_DIR.resolve(abi));
}
public GameAILoader() {
_finder = new ClassAIFinder();
_classes = _finder.getAIClasses(AI.class, "ch.hesso");
ImmutableMap.Builder<String, AI> builder = ImmutableMap.builder();
for (Class<? extends AI> ai : _classes) {
try {
AI instance = ai.newInstance();
instance.initialize(GameController.this);
if (instance.kind().equals(PLAYER)) {
_default = instance;
_defaultAIName = instance.name();
}
builder.put(instance.name(), instance);
initClassFields(ai, instance);
} catch (InstantiationException | IllegalAccessException e) {
LOG.log(Level.SEVERE, "[GameController.GameAILoader.GameAILoader]: " + e.getMessage());
}
}
_ais = builder.build();
if (_default == null && _ais.size() > 0) {
_default = _ais.values().asList().get(0);
_defaultAIName = _ais.keySet().asList().get(0);
}
}
/** Implements {@link FileSystem#supportedFileAttributeViews()}. */
public ImmutableSet<String> supportedFileAttributeViews() {
return providersByName.keySet();
}
public Iterator<String> iterator() {
return vals.keySet().iterator();
}
public Set<Integer> longsIndeces() {
return longPositions.keySet();
}
/** Returns the (immutable, unordered) set of names of all the known rule classes. */
public Set<String> getRuleClassNames() {
return ruleClassMap.keySet();
}
@Override
public HttpRequest filter(HttpRequest request) throws HttpException {
checkArgument(
request.getHeaders().containsKey(HOST), "request is not ready to sign; host not present");
String host = request.getFirstHeaderOrNull(HOST);
String form = request.getPayload().getRawContent().toString();
checkArgument(
form.indexOf(ACTION) != -1, "request is not ready to sign; Action not present %s", form);
String timestamp = iso8601Timestamp.get();
String datestamp = timestamp.substring(0, 8);
String service = serviceAndRegion.service();
String region = serviceAndRegion.region(host);
String credentialScope = Joiner.on('/').join(datestamp, region, service, "aws4_request");
// content-type is not a required signing param. However, examples use this, so we include it to
// ease testing.
ImmutableMap.Builder<String, String> signedHeadersBuilder =
ImmutableMap.<String, String>builder() //
.put("content-type", request.getPayload().getContentMetadata().getContentType()) //
.put("host", host) //
.put("x-amz-date", timestamp);
HttpRequest.Builder<?> requestBuilder =
request
.toBuilder() //
.removeHeader(AUTHORIZATION) //
.replaceHeader("X-Amz-Date", timestamp);
if (form.indexOf(VERSION) == -1) {
requestBuilder.addFormParam("Version", apiVersion);
}
Credentials credentials = creds.get();
if (credentials instanceof SessionCredentials) {
String token = SessionCredentials.class.cast(credentials).getSessionToken();
requestBuilder.replaceHeader("X-Amz-Security-Token", token);
signedHeadersBuilder.put("x-amz-security-token", token);
}
ImmutableMap<String, String> signedHeaders = signedHeadersBuilder.build();
String stringToSign =
createStringToSign(requestBuilder.build(), signedHeaders, credentialScope);
byte[] signatureKey = signatureKey(credentials.credential, datestamp, region, service);
String signature = base16().lowerCase().encode(hmacSHA256(stringToSign, signatureKey));
StringBuilder authorization = new StringBuilder("AWS4-HMAC-SHA256 ");
authorization
.append("Credential=")
.append(credentials.identity)
.append('/')
.append(credentialScope)
.append(", ");
authorization
.append("SignedHeaders=")
.append(Joiner.on(';').join(signedHeaders.keySet()))
.append(", ");
authorization.append("Signature=").append(signature);
return requestBuilder.addHeader(AUTHORIZATION, authorization.toString()).build();
}
public Iterator<String> iterator() {
return params.keySet().iterator();
}