private void InvokeHelper(AsyncResult asyncResult)
{
if (asyncResult.RetriesAttempt == 0 || Config.ResignRetries)
{
if (Credentials is CognitoAWSCredentials)
{
var cred = Credentials as CognitoAWSCredentials;
// very hacky solution
cred.GetCredentialsAsync(delegate(AmazonServiceResult voidResult)
{
if (voidResult.Exception != null)
{
asyncResult.IsCompleted = true;
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "CognitoAWSCredentials", voidResult.Exception.Message);
asyncResult.HandleException(voidResult.Exception);
return;
}
ProcessHttpRequest(asyncResult);
}, null);
return;
}
}
ProcessHttpRequest(asyncResult);
return;
}
private void loadCachedCredentials()
{
String AK = _persistentStore.Get(AK_KEY);
String SK = _persistentStore.Get(SK_KEY);
String ST = _persistentStore.Get(ST_KEY);
String EXP = _persistentStore.Get(EXP_KEY);
string IP = _persistentStore.Get(IP_KEY);
long ticks = EXP != null?long.Parse(EXP) : 0;
// make sure we have valid data in prefs
if (AK == null || SK == null ||
ST == null || IP == null)
{
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "No valid credentials found in LocalStorage");
_currentState = null;
return;
}
_currentState = new CredentialsRefreshState
{
Credentials = new ImmutableCredentials(AK, SK, ST),
Expiration = new DateTime(ticks)
};
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Loaded credentials from LocalStorage");
}
/// <summary>
/// Increments the delivery attempt.
/// </summary>
/// <returns>true</returns>
/// <c>false</c>
/// <param name="rowIds">Row identifiers.</param>
public bool IncrementDeliveryAttempt(List <string> rowIds)
{
bool success = false;
lock (_lock)
{
SQLiteStatement stmt = null;
try
{
#if SQL_DEBUG
DateTime _dbExecutionStartTime = DateTime.Now;
#endif
string ids = "'" + String.Join("', '", rowIds.ToArray()) + "'";
string query = String.Format("UPDATE " + TABLE_NAME + " SET " + EVENT_DELIVERY_ATTEMPT_COUNT_COLUMN_NAME + "= " + EVENT_DELIVERY_ATTEMPT_COUNT_COLUMN_NAME + "+1 WHERE " + EVENT_ID_COLUMN_NAME + " IN ({0})", ids);
stmt = db.Prepare(query);
stmt.Step();
success = true;
#if SQL_DEBUG
DateTime _dbExecutionEndTime = DateTime.Now;
double totalSeconds = _dbExecutionEndTime.Subtract(_dbExecutionStartTime).TotalSeconds;
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "SQLiteEventStore", "Increment Operation completed on local store in " + totalSeconds + " seconds");
#endif
}
finally
{
if (stmt != null)
{
stmt.FinalizeStm();
}
}
}
return(success);
}
protected void GenerateNewCredentialsAsync(AmazonServiceCallback callback)
{
AmazonServiceResult voidResult = new AmazonServiceResult(null, null);
IdentityProvider.RefreshAsync(delegate(AmazonServiceResult refreshResult)
{
if (refreshResult.Exception != null)
{
voidResult.Exception = refreshResult.Exception;
AmazonMainThreadDispatcher.ExecCallback(callback, voidResult);
return;
}
// Pick role to use, depending on Logins
string roleArn = UnAuthRoleArn;
if (IdentityProvider.Logins.Count > 0)
{
roleArn = AuthRoleArn;
}
if (string.IsNullOrEmpty(roleArn))
{
voidResult.Exception = new AmazonServiceException(
new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Unable to determine Role ARN. AuthRoleArn = [{0}], UnAuthRoleArn = [{1}], Logins.Count = {2}",
AuthRoleArn, UnAuthRoleArn, IdentityProvider.Logins.Count)));
AmazonMainThreadDispatcher.ExecCallback(callback, voidResult);
return;
}
// Assume role with Open Id Token
var assumeRequest = new AssumeRoleWithWebIdentityRequest
{
WebIdentityToken = IdentityProvider.GetCurrentOpenIdToken(),
RoleArn = roleArn,
RoleSessionName = "UnityProviderSession",
DurationSeconds = DefaultDurationSeconds
};
sts.AssumeRoleWithWebIdentityAsync(assumeRequest, delegate(AmazonServiceResult result)
{
if (result.Exception != null)
{
voidResult.Exception = result.Exception;
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "STS", result.Exception.Message);
AmazonMainThreadDispatcher.ExecCallback(callback, voidResult);
return;
}
AssumeRoleWithWebIdentityResponse assumeRoleWithWebIdentityResponse = result.Response as AssumeRoleWithWebIdentityResponse;
this._currentState = new CredentialsRefreshState
{
Credentials = assumeRoleWithWebIdentityResponse.Credentials.GetCredentials(),
Expiration = assumeRoleWithWebIdentityResponse.Credentials.Expiration
};
// success - FinalResponse
AmazonMainThreadDispatcher.ExecCallback(callback, voidResult);
return;
}, null);
}, null);
}
protected void InvokeS3Post(PostObjectRequest publicrequest, AmazonServiceCallback callback, object state)
{
AsyncResult asyncResult = new AsyncResult(new DefaultRequest(publicrequest, "Amazon.S3"),
publicrequest, callback,
state, new S3Signer(), null);
try
{
asyncResult.Metrics.StartEvent(Metric.ClientExecuteTime);
asyncResult.Request.Endpoint = DetermineEndpoint(asyncResult.Request);
if (Config.LogMetrics)
{
asyncResult.Metrics.IsEnabled = true;
asyncResult.Metrics.AddProperty(Metric.ServiceName, asyncResult.Request.ServiceName);
asyncResult.Metrics.AddProperty(Metric.ServiceEndpoint, asyncResult.Request.Endpoint);
asyncResult.Metrics.AddProperty(Metric.MethodName, asyncResult.RequestName);
asyncResult.Metrics.AddProperty(Metric.AsyncCall, !asyncResult.CompletedSynchronously);
}
//ConfigureRequest(asyncResult);
InvokeHelperForS3PostObject(asyncResult, publicrequest);
}
catch (Exception e)
{
AmazonLogging.LogException(AmazonLogging.AmazonLoggingLevel.Errors, "S3", e);
asyncResult.IsCompleted = true;
asyncResult.HandleException(e);
return;
}
//return asyncResult;
}
/// <summary>
/// Constructs a new CognitoAWSCredentials instance, which will use the
/// specified Amazon Cognito identity pool to make a requests to the
/// AWS Security Token Service (STS) to request short lived session credentials.
/// </summary>
/// <param name="accountId">The AWS accountId for the account with Amazon Cognito</param>
/// <param name="identityPoolId">The Amazon Cogntio identity pool to use</param>
/// <param name="unAuthRoleArn">The ARN of the IAM Role that will be assumed when unauthenticated</param>
/// <param name="authRoleArn">The ARN of the IAM Role that will be assumed when authenticated</param>
/// <param name="region">Region to use when accessing Amazon Cognito and AWS Security Token Service.</param>
public CachingCognitoAWSCredentials(
string accountId, string identityPoolId,
string unAuthRoleArn, string authRoleArn,
RegionEndpoint region)
: this(
unAuthRoleArn, authRoleArn,
new AmazonCognitoIdentityProvider(accountId, identityPoolId, new AnonymousAWSCredentials(), region),
new AmazonSecurityTokenServiceClient(new AnonymousAWSCredentials(), region))
{
if (string.IsNullOrEmpty(accountId))
{
throw new ArgumentNullException("accountId cannot be null");
}
if (string.IsNullOrEmpty(identityPoolId))
{
throw new ArgumentNullException("identityPoolId cannot be null");
}
if (string.IsNullOrEmpty(unAuthRoleArn) && string.IsNullOrEmpty(authRoleArn))
{
throw new ArgumentNullException("Both unAuthRoleArn and authRoleArn cannot be null");
}
#if UNITY_WEBPLAYER
_persistentStore = new InMemoryKVStore();
#else
_persistentStore = new SQLiteKVStore();
#endif
string IP = _persistentStore.Get(IP_KEY);
if (!string.IsNullOrEmpty(IP) && 0 == IP.CompareTo(identityPoolId))
{
IdentityProvider.UpdateIdentity(_persistentStore.Get(ID_KEY));
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Loaded Cached IdentityID from LocalStorage");
loadCachedCredentials();
}
else if (!string.IsNullOrEmpty(IP))
{
// identity pool id is different from whats caching
Clear();
}
IdentityProvider.IdentityChangedEvent += delegate(object sender, IdentityChangedArgs e)
{
if (!string.IsNullOrEmpty(e.OldIdentityId))
{
this.Clear();
}
if (string.IsNullOrEmpty(_persistentStore.Get(IP_KEY)))
{
// identity pool id is not cached
_persistentStore.Put(IP_KEY, this.IdentityProvider.IdentityPoolId);
}
// caching identity whenever new identity is found
_persistentStore.Put(ID_KEY, e.NewIdentityId);
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Saved identityID to LocalStorage");
};
}
public void IdentityChanged(object sender, EventArgs e)
{
var identityChangedEvent = e as IdentityChangedArgs;
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Info, "DefaultCognitoSyncManager", "identity change detected");
local.ChangeIdentityId(identityChangedEvent.OldIdentityId == null ? DatasetUtils.UNKNOWN_IDENTITY_ID
: identityChangedEvent.OldIdentityId, identityChangedEvent.NewIdentityId);
}
internal void ClearCredentials()
{
_sessionCredentials = null;
_persistentStore.Clear(namespacedKey(AK_KEY));
_persistentStore.Clear(namespacedKey(SK_KEY));
_persistentStore.Clear(namespacedKey(ST_KEY));
_persistentStore.Clear(namespacedKey(EXP_KEY));
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CognitoAWSCredentials", "Clear Credentials");
}
public void Debug(String msg)
{
#if UNITY_EDITOR || UNITY_IPHONE || UNITY_ANDROID
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, tag, msg);
#elif __ANDROID__
Android.Util.Log.Debug(tag, msg);
#elif __IOS__
System.Console.WriteLine(msg);
#endif
}
// fetching/persisting new credentials in LocalStorage
public override void GetCredentialsAsync(AmazonServiceCallback callback, object state)
//internal IEnumerator GetCredentialsCoroutine(VoidResponse voidResponse)
{
//lock (this._refreshLock)
//{
//
if (_currentState == null)
{
loadCachedCredentials();
}
// If credentials are expired, update
if (ShouldUpdate)
{
GenerateNewCredentialsAsync(delegate(AmazonServiceResult voidResult)
{
if (voidResult.Exception != null)
{
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "Cognito", "Error occured during GetCredentialsAsync");
AmazonMainThreadDispatcher.ExecCallback(callback, new AmazonServiceResult(null, null, voidResult.Exception, state));
return;
}
// Check if the new credentials are already expired
if (ShouldUpdate)
{
voidResult.Exception = new AmazonServiceException("The retrieved credentials have already expired");
AmazonMainThreadDispatcher.ExecCallback(callback, new AmazonServiceResult(null, null, voidResult.Exception, state));
return;
}
// Offset the Expiration by PreemptExpiryTime
_currentState.Expiration -= PreemptExpiryTime;
if (ShouldUpdate)
{
// This could happen if the default value of PreemptExpiryTime is
// overriden and set too high such that ShouldUpdate returns true.
voidResult.Exception = new AmazonClientException(String.Format(
"The preempt expiry time is set too high: Current time = {0}, Credentials expiry time = {1}, Preempt expiry time = {2}.",
DateTime.Now, _currentState.Expiration, PreemptExpiryTime));
AmazonMainThreadDispatcher.ExecCallback(callback, new AmazonServiceResult(null, null, voidResult.Exception, state));
return;
}
saveCredentials();
AmazonMainThreadDispatcher.ExecCallback(callback, new AmazonServiceResult(null, null, null, state));
});
return;
}
AmazonMainThreadDispatcher.ExecCallback(callback, new AmazonServiceResult(null, null, null, state));
//}
}
internal override void Clear()
{
base.Clear();
_persistentStore.Clear(IP_KEY);
_persistentStore.Clear(ID_KEY);
_persistentStore.Clear(AK_KEY);
_persistentStore.Clear(SK_KEY);
_persistentStore.Clear(ST_KEY);
_persistentStore.Clear(EXP_KEY);
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Clear Cached Credentials");
}
private void saveCredentials()
{
if (_sessionCredentials != null)
{
_persistentStore.Put(namespacedKey(AK_KEY), _sessionCredentials.Credentials.AccessKey);
_persistentStore.Put(namespacedKey(SK_KEY), _sessionCredentials.Credentials.SecretKey);
_persistentStore.Put(namespacedKey(ST_KEY), _sessionCredentials.Credentials.Token);
_persistentStore.Put(namespacedKey(EXP_KEY), _sessionCredentials.Expiration.Ticks.ToString());
_persistentStore.Put(namespacedKey(ID_KEY), IdentityProvider.GetCurrentIdentityId());
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CognitoAWSCredentials", "Saved credentials to LocalStorage");
}
}
private void saveCredentials()
{
if (_currentState != null)
{
_persistentStore.Put(AK_KEY, _currentState.Credentials.AccessKey);
_persistentStore.Put(SK_KEY, _currentState.Credentials.SecretKey);
_persistentStore.Put(ST_KEY, _currentState.Credentials.Token);
_persistentStore.Put(EXP_KEY, _currentState.Expiration.Ticks.ToString());
_persistentStore.Put(IP_KEY, IdentityProvider.IdentityPoolId);
_persistentStore.Put(ID_KEY, IdentityProvider.GetCurrentIdentityId());
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Saved credentials to LocalStorage");
}
}
public override void Put(string key, string value)
{
lock (SQLiteDatabase.SQLiteLock)
{
string query = "SELECT count(*) as count FROM " + TABLE_RECORDS + " where " + COLUMN_KEY + " = ?";
SQLiteStatement stmt = null;
try
{
stmt = db.Prepare(query);
stmt.BindText(1, key);
if (stmt.Read())
{
long count = stmt.Fields["count"].INTEGER;
stmt.FinalizeStm();
if (count == 0)
{
// insert record
query = "INSERT INTO " + TABLE_RECORDS + " (" + COLUMN_KEY + ", " + COLUMN_VALUE + ") VALUES(?,?)";
stmt = db.Prepare(query);
stmt.BindText(1, key);
stmt.BindText(2, value);
stmt.Step();
return;
}
else
{
// update record
query = "UPDATE " + TABLE_RECORDS + " SET " + COLUMN_VALUE + " = ? where " + COLUMN_KEY + " = ?";
stmt = db.Prepare(query);
stmt.BindText(2, key);
stmt.BindText(1, value);
stmt.Step();
return;
}
}
else
{
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "SQLiteKVStore", "Save failed");
throw new Exception("Save failed");
}
}
finally
{
if (stmt != null)
{
stmt.FinalizeStm();
}
}
}
}
private void ProcessS3PostResponse(object state)
{
AsyncResult asyncResult = null;
try
{
asyncResult = state as AsyncResult;
asyncResult.ServiceResult.HttpResponseData = asyncResult.ResponseData;
S3PostUploadResponse response = new S3PostUploadResponse();
WWWResponseData responseData = asyncResult.ResponseData;
if (!String.IsNullOrEmpty(responseData.Error) || !String.IsNullOrEmpty(System.Text.Encoding.UTF8.GetString(responseData.GetBytes())))
{
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Critical, "S3", responseData.Error);
foreach (string key in responseData.GetHeaderNames())
{
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "S3", key + " : " + responseData.GetHeaderValue(key));
}
if (asyncResult.Exception == null)
{
asyncResult.Exception = new AmazonServiceException("Bad Request");
}
asyncResult.IsCompleted = true;
response.StatusCode = HttpStatusCode.BadRequest;
asyncResult.ServiceResult.Response = response;
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Warnings, "S3", "RetriesAttempt exceeded");
asyncResult.HandleException(asyncResult.Exception);
return;
}
else
{
asyncResult.IsCompleted = true;
response.StatusCode = HttpStatusCode.NoContent;
asyncResult.ServiceResult.Response = response;
asyncResult.InvokeCallback();
return;
}
}
catch (Exception e)
{
Debug.LogException(e);
asyncResult.HandleException(e);
return;
}
}
private static void Execute <T>(AsyncCall call, DynamoDBAsyncState <T> result)
{
try
{
result.Return = call();
AmazonMainThreadDispatcher.ExecCallback <T>(result.Callback, new AmazonDynamoResult <T>((T)result.Return, null, result.State));
return;
}
catch (Exception ex)
{
AmazonLogging.LogException(AmazonLogging.AmazonLoggingLevel.Errors, result.Operation, ex);
AmazonMainThreadDispatcher.ExecCallback <T>(result.Callback, new AmazonDynamoResult <T>(default(T), ex, result.State));
return;
}
}
/// <summary>
/// The HandleWWWErrorResponse differs significantly from the error handling doing in .NET sdk
/// since the www.error string message is incomplete
/// so this requires rewriting all responseunmarshallers.HandleErrorContext which is not part of this version
/// hence exception thrown will always be of base type AmazonServiceException
/// </summary>
/// <returns>True if the error needs retry</returns>
private bool HandleWWWErrorResponse(AsyncResult asyncResult)
{
WWWResponseData errorResponse = asyncResult.ResponseData;
asyncResult.Metrics.AddProperty(Metric.Exception, errorResponse.Error);
AmazonServiceException errorResponseException = null;
errorResponseException = new AmazonServiceException(errorResponse.Error,
new WebException(errorResponse.Error));
errorResponseException.UnityStatusCode = errorResponse.Error;
try
{
errorResponseException.StatusCode = errorResponse.ErrorStatusCode;
}
catch (Exception e)
{
// Parsing exception
AmazonLogging.LogException(AmazonLogging.AmazonLoggingLevel.Errors, asyncResult.Request.RequestName, e);
}
string curl = "curl " + (asyncResult.Request.HttpMethod == "GET" &&
!HttpOverrideSupportedServices.Contains(asyncResult.Request.ServiceName) ?
"-G " : "-X POST ");
foreach (string key in asyncResult.RequestData.Headers.Keys)
{
curl += " -H \"" + key + ": " + asyncResult.RequestData.Headers[key] + "\" ";
}
if (asyncResult.RequestData.Data != null)
{
curl += " -d '" + System.Text.Encoding.Default.GetString(asyncResult.RequestData.Data) + "' ";
}
curl += " " + asyncResult.RequestData.Url;
Debug.LogError(curl);
if (errorResponse.IsHeaderPresent(HeaderKeys.XAmzRequestIdHeader.ToUpper()))
{
errorResponseException.RequestId = errorResponse.GetHeaderValue(HeaderKeys.XAmzRequestIdHeader);
}
asyncResult.Exception = errorResponseException;
// currently no retries are done
return(false);
}
public override void PutValue(string identityId, string datasetName, string key, string value)
{
lock (SQLiteDatabase.SQLiteLock)
{
bool result = this.PutValueInternal(identityId, datasetName, key, value);
if (!result)
{
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "SQLite", "PutValue failed");
}
else
{
this.UpdateLastModifiedTimestamp(identityId, datasetName);
}
}
}
private void InvokeHelperForS3PostObject(AsyncResult asyncResult, PostObjectRequest request)
{
if (asyncResult.RetriesAttempt == 0 || Config.ResignRetries)
{
// Add Post policy
if (request.PostPolicy == null)
{
int position = request.Key.LastIndexOf('.');
string ext = null, contentType = null;
if (position != -1)
{
ext = request.Key.Substring(position, request.Key.Length - position);
contentType = AmazonS3Util.MimeTypeFromExtension(ext);
}
else
{
contentType = "application/octet-stream";
}
request.PostPolicy = S3PostPolicyBuilder.GetPostPolicy(request.Bucket, request.Key, contentType);
}
if (Credentials is CognitoAWSCredentials)
{
var cred = Credentials as CognitoAWSCredentials;
// very hacky solution
cred.GetCredentialsAsync(delegate(AmazonServiceResult voidResult)
{
if (voidResult.Exception != null)
{
asyncResult.IsCompleted = true;
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "CognitoAWSCredentials", voidResult.Exception.Message);
asyncResult.HandleException(voidResult.Exception);
return;
}
request.SignedPolicy = S3PostUploadSignedPolicy.GetSignedPolicy(request.PostPolicy, cred);
ProcessS3PostRequest(asyncResult, request);
}, null);
return;
}
request.SignedPolicy = S3PostUploadSignedPolicy.GetSignedPolicy(request.PostPolicy, Credentials);
}
ProcessS3PostRequest(asyncResult, request);
}
/// <summary>
/// Get All event from the Event Store
/// </summary>
/// <param name="appid">Appid.</param>
/// <returns>All the events as a List of <see cref="ThirdParty.Json.LitJson.JsonData"/>.</returns>
public List <JsonData> GetAllEvents(string appId)
{
List <JsonData> eventList = new List <JsonData>();
lock (_lock)
{
SQLiteStatement stmt = null;
try
{
#if SQL_DEBUG
DateTime _dbExecutionStartTime = DateTime.Now;
#endif
string query = "SELECT * FROM " + TABLE_NAME + " WHERE " + MA_APP_ID_COLUMN_NAME + " = ? ORDER BY " + EVENT_DELIVERY_ATTEMPT_COUNT_COLUMN_NAME + ",ROWID LIMIT " + MAX_ALLOWED_SELECTS;
stmt = db.Prepare(query);
stmt.BindText(1, appId);
while (stmt.Read())
{
JsonData data = new JsonData();
data["id"] = stmt.Fields[EVENT_ID_COLUMN_NAME].TEXT;
data["event"] = stmt.Fields[EVENT_COLUMN_NAME.ToLower()].TEXT;
data["appId"] = stmt.Fields[MA_APP_ID_COLUMN_NAME].TEXT;
eventList.Add(data);
}
#if SQL_DEBUG
DateTime _dbExecutionEndTime = DateTime.Now;
double totalSeconds = _dbExecutionEndTime.Subtract(_dbExecutionStartTime).TotalSeconds;
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "SQLiteEventStore", "Select All Operation completed from local store in " + totalSeconds + " seconds");
#endif
}
catch (Exception e)
{
_logger.Error(e, "Exception happens when getting events.");
}
finally
{
if (stmt != null)
{
stmt.FinalizeStm();
}
}
}
return(eventList);
}
public static void LoadEndpointDefinitions()
{
try
{
TextAsset awsEndpoints = UnityEngine.Resources.Load("aws_endpoints_json") as TextAsset;
using (Stream stream = new MemoryStream(awsEndpoints.bytes))
{
using (StreamReader reader = new StreamReader(stream))
{
LoadEndpointDefinitions(reader);
}
}
}
catch (System.Exception exception)
{
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.ErrorsAsExceptions, "LoadEndpointDefinitions",
"cannot load service endpoint file : " + exception.Message);
}
}
protected bool DefaultConflictResolution(List <SyncConflict> conflicts)
{
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Info, this.GetType().ToString(), "Last writer wins conflict resolution for dataset ");
List <Record> resolvedRecords = new List <Record>();
foreach (SyncConflict conflict in conflicts)
{
if (conflict.RemoteRecord == null || conflict.LocalRecord.LastModifiedDate.Value.CompareTo(conflict.RemoteRecord.LastModifiedDate) > 0)
{
resolvedRecords.Add(conflict.ResolveWithLocalRecord());
}
else
{
resolvedRecords.Add(conflict.ResolveWithRemoteRecord());
}
}
this.Resolve(resolvedRecords);
return(true);
}
private IEnumerator FireNetworkRequestCoroutine(AsyncResult result)
{
// this check is probably not needed since Dequeue operation is supposed to invoked only from the Unity MainThread
if (result != null)
{
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, result.Request.ServiceName,
"Making WWW request");
// making WWW request call
yield return(result.RequestData.FireRequest());
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, result.Request.ServiceName,
"Completing WWW request");
result.ResponseData = result.RequestData.GetResponseData();
// switching to background thread
ThreadPool.QueueUserWorkItem(result.WaitCallback, (object)result);
}
RequestPending--;
yield break;
}
/// <summary>
/// Constructs a new CognitoAWSCredentials instance, which will use the
/// specified Amazon Cognito identity pool to make a requests to the
/// AWS Security Token Service (STS) to request short lived session credentials.
/// </summary>
/// <param name="accountId">The AWS accountId for the account with Amazon Cognito</param>
/// <param name="identityPoolId">The Amazon Cogntio identity pool to use</param>
/// <param name="unAuthRoleArn">The ARN of the IAM Role that will be assumed when unauthenticated</param>
/// <param name="authRoleArn">The ARN of the IAM Role that will be assumed when authenticated</param>
/// <param name="cibClient">Preconfigured Cognito Identity client to make requests with</param>
/// <param name="stsClient">Preconfigured STS client to make requests with</param>
public CognitoAWSCredentials(string unAuthRoleArn, string authRoleArn,
AbstractCognitoIdentityProvider idClient, IAmazonSecurityTokenService stsClient)
{
if (idClient == null)
{
throw new ArgumentNullException("idClient");
}
UnAuthRoleArn = unAuthRoleArn;
AuthRoleArn = authRoleArn;
IdentityProvider = idClient;
sts = stsClient;
#if UNITY_WEBPLAYER
_persistentStore = new InMemoryKVStore();
#else
_persistentStore = new SQLiteKVStore();
#endif
//Load cached credentials
string cachedIdentity = _persistentStore.Get(namespacedKey(ID_KEY));
if (string.IsNullOrEmpty(cachedIdentity))
{
//Try to recover unamespaced identities stored by old versions of the SDK
cachedIdentity = _persistentStore.Get(ID_KEY);
}
if (!string.IsNullOrEmpty(cachedIdentity))
{
IdentityProvider.UpdateIdentity(cachedIdentity);
loadCachedCredentials();
}
//Register Identity Changed Listener to update the cache
IdentityProvider.IdentityChangedEvent += delegate(object sender, IdentityChangedArgs e)
{
saveCredentials();
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CognitoAWSCredentials", "Saved identityID to LocalStorage");
};
}
protected void Invoke <T, R>(R request, AmazonServiceCallback callback, object state, IMarshaller <T, R> marshaller, ResponseUnmarshaller unmarshaller, AbstractAWSSigner signer)
where T : IRequest
where R : AmazonWebServiceRequest
{
AsyncResult result = null;
try
{
ProcessPreRequestHandlers(request);
IRequest irequest = marshaller.Marshall(request);
result = new AsyncResult(irequest, request, callback, state, signer, unmarshaller);
Invoke(result);
}
catch (Exception e)
{
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "Runtime", e.Message);
result.HandleException(e);
result.IsCompleted = true;
}
//return result;
}
public override void Synchronize()
{
ThreadPool.QueueUserWorkItem(delegate(object notUsed)
{
if (!IsNetworkAvailable())
{
FireSyncFailureEvent(new NetworkException("Network connectivity unavailable."));
return;
}
List <string> mergedDatasets = GetLocalMergedDatasets();
if (mergedDatasets.Count > 0)
{
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "DefaultDataset", "detected merge datasets " + _datasetName);
if (this.OnDatasetMerged != null)
{
this.OnDatasetMerged(this, mergedDatasets);
}
}
if (_cognitoCredentials.IdentityProvider.GetCurrentIdentityId() != null)
{
SynchronizeInternalAsync();
}
else
{
_cognitoCredentials.IdentityProvider.RefreshAsync(delegate(AmazonServiceResult voidResult)
{
if (voidResult.Exception != null)
{
FireSyncFailureEvent(voidResult.Exception);
return;
}
SynchronizeInternalAsync();
}, null);
}
});
}
public void SynchronizeInternalAsync()
{
try
{
List <string> mergedDatasets = GetLocalMergedDatasets();
if (mergedDatasets.Count != 0)
{
this.OnDatasetMerged(this, mergedDatasets);
}
this.RunSyncOperationAsync(MAX_RETRY, delegate(RunSyncOperationResponse response)
{
if (response == null || response.Exception != null)
{
FireSyncFailureEvent(new DataStorageException("Unknown exception", response.Exception));
}
});
}
catch (Exception e)
{
FireSyncFailureEvent(new DataStorageException("Unknown exception", e));
AmazonLogging.LogError(AmazonLogging.AmazonLoggingLevel.Errors, "CognitoSyncManager", "failed to synchronize " + e.Message);
}
}
/// <summary>
/// Log the GameCircle message.
/// </summary>
/// <param name='message'>
/// Message.
/// </param>
public static void Log(string message)
{
AmazonLogging.Log(errorLevel, serviceName, message);
}
/// <summary>
/// Logs the GameCircle warning.
/// </summary>
/// <param name='errorMessage'>
/// Error message.
/// </param>
public static void LogGameCircleWarning(string errorMessage)
{
AmazonLogging.LogWarning(errorLevel, serviceName, errorMessage);
}
public override void WipeData()
{
local.WipeData();
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Info, "DefaultCognitoSyncManager", "All data has been wiped");
}