private static double GetTimerIntervalOrDefault(bool isGC)
{
double num = 900000;
try
{
if (!isGC)
{
num = 900000;
double num1 = double.Parse(Environment.GetEnvironmentVariable("DEVSTORE_DEFRAGMENT_FILES_MILLIS", EnvironmentVariableTarget.User));
if (num1 >= 30000)
{
num = num1;
}
}
else
{
num = 900000;
double num2 = double.Parse(Environment.GetEnvironmentVariable("DEVSTORE_DELETE_FILES_MILLIS", EnvironmentVariableTarget.User));
if (num2 >= 30000)
{
num = num2;
}
}
}
catch (Exception exception1)
{
Exception exception = exception1;
IStringDataEventStream infoDebug = Logger <INormalAndDebugLogger> .Instance.InfoDebug;
object[] objArray = new object[] { isGC, exception.StackTrace };
infoDebug.Log("BlockBlob: Load Interval failed. IsGC: {0}, Exception {1}", objArray);
}
return(num);
}
public static bool ShouldSendAlert(string alertKey, TimeSpan?alertIntervalOverride = null)
{
bool flag = false;
int num = 60;
TimeSpan timeSpan = (alertIntervalOverride.HasValue ? alertIntervalOverride.Value : TimeSpan.FromMinutes((double)num));
lock (AlertsManager.mapSync)
{
if (!AlertsManager.alertLoggingMap.ContainsKey(alertKey) || DateTime.UtcNow > AlertsManager.alertLoggingMap[alertKey])
{
if (AlertsManager.alertLoggingMap.Count > 1000)
{
AlertsManager.alertLoggingMap.Clear();
IStringDataEventStream verbose = Logger <IRestProtocolHeadLogger> .Instance.Verbose;
object[] count = new object[] { AlertsManager.alertLoggingMap.Count };
verbose.Log("AlertsManager: map reached {0} entries, clearing map.", count);
}
flag = true;
AlertsManager.alertLoggingMap[alertKey] = DateTime.UtcNow + timeSpan;
IStringDataEventStream stringDataEventStream = Logger <IRestProtocolHeadLogger> .Instance.Verbose;
object[] objArray = new object[] { alertKey, timeSpan.TotalMinutes };
stringDataEventStream.Log("AlertsManager: next alert for message '{0}' will be in {1} minutes", objArray);
}
}
return(flag);
}
private IEnumerator <IAsyncResult> CreateTableContainerImpl(string tableName, DateTime?expiryTime, byte[] serviceMetadata, byte[] applicationMetadata, AsyncIteratorContext <ITableContainer> context)
{
IAsyncResult asyncResult;
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { tableName, expiryTime, serviceMetadata, applicationMetadata, this.Timeout };
verboseDebug.Log("CreateTableContainerImpl({0},{1},{2},{3},{4})", objArray);
try
{
asyncResult = this.internalAccount.BeginCreateTableContainer(tableName, StorageStampHelpers.AdjustNullableDatetimeRange(expiryTime), serviceMetadata, applicationMetadata, context.GetResumeCallback(), context.GetResumeState("StorageAccount.CreateTableContainerImpl"));
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
yield return(asyncResult);
try
{
ITableContainer tableContainer = this.internalAccount.EndCreateTableContainer(asyncResult);
context.ResultData = new TableContainer(tableContainer);
}
catch (Exception exception1)
{
StorageStamp.TranslateException(exception1);
throw;
}
}
private IEnumerator <IAsyncResult> CreateQueueContainerImpl(string containerName, DateTime?expiryTime, byte[] serviceMetadata, byte[] applicationMetadata, AsyncIteratorContext <IQueueContainer> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { containerName, expiryTime, serviceMetadata, applicationMetadata, this.Timeout };
verboseDebug.Log("CreateQueueContainerImpl({0},{1},{2},{3},{4})", objArray);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute <DbQueueContainer>((TimeSpan param0) => {
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = new Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer()
{
AccountName = this._account.Name,
QueueName = containerName,
ServiceMetadata = serviceMetadata,
Metadata = applicationMetadata
};
DbQueueContainer dbQueueContainer = new DbQueueContainer(this, queueContainer);
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
dbContext.QueueContainers.InsertOnSubmit(queueContainer);
dbContext.SubmitChanges();
}
return(dbQueueContainer);
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("StorageAccount.CreateQueueContainer"));
yield return(asyncResult);
context.ResultData = this.StorageManager.AsyncProcessor.EndExecute <DbQueueContainer>(asyncResult);
}
internal static HttpProcessorConfiguration LoadHttpProcessorConfiguration(IServiceEntrySink sink, string hostSuffixesConfigParamName, string enableStorageDomainNamesConfigParamName)
{
HttpProcessorConfiguration httpProcessorConfiguration = new HttpProcessorConfiguration()
{
AllowPathStyleUris = ConfigurationHelper.GetConfigSetting <bool>(sink, "NephosAllowPathStyleUris", "Allow path-style URIs"),
ValidHostSuffixes = ConfigurationHelper.GetHostSuffixes(sink, hostSuffixesConfigParamName),
MaskClientIPAddressesInLog = ConfigurationHelper.GetIPAddressMaskSetting(sink)
};
if (!httpProcessorConfiguration.AllowPathStyleUris)
{
NephosAssertionException.Assert(httpProcessorConfiguration.ValidHostSuffixes != null, "Host suffixes can't be null when AllowPathStyleUris is false. Check service model configuaration.");
NephosAssertionException.Assert((int)httpProcessorConfiguration.ValidHostSuffixes.Length > 0, "Host suffixes can't be empty when AllowPathStyleUris is false. Check service model configuaration.");
}
httpProcessorConfiguration.ValidHostSuffixes = httpProcessorConfiguration.ValidHostSuffixes ?? new string[0];
httpProcessorConfiguration.IncludeInternalDetailsInErrorResponses = ConfigurationHelper.GetConfigSetting <bool>(sink, "NephosIncludeInternalDetailsInErrorResponses", "Include internal details in error responses");
if (!string.IsNullOrEmpty(enableStorageDomainNamesConfigParamName))
{
httpProcessorConfiguration.EnableStorageDomainNames = ConfigurationHelper.GetConfigSetting <bool>(sink, enableStorageDomainNamesConfigParamName, "Enable storage domain names");
}
try
{
httpProcessorConfiguration.StampName = ConfigurationHelper.GetConfigSetting <string>(sink, "StampName", "Stamp Name");
}
catch (Exception exception1)
{
Exception exception = exception1;
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] str = new object[] { exception.ToString() };
error.Log("Hit Exception while reading StampName setting from ACS: {0}", str);
}
return(httpProcessorConfiguration);
}
private void ProcessAsyncCallback(IAsyncResult ar)
{
Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug.Log("In the process end callback");
using (IProcessor asyncState = (IProcessor)ar.AsyncState)
{
try
{
asyncState.EndProcess(ar);
}
catch (NephosAssertionException nephosAssertionException1)
{
NephosAssertionException nephosAssertionException = nephosAssertionException1;
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] str = new object[] { nephosAssertionException.ToString() };
error.Log("ASSERTION: {0}", str);
}
catch (Exception exception1)
{
Exception exception = exception1;
IStringDataEventStream unhandledException = Logger <IRestProtocolHeadLogger> .Instance.UnhandledException;
object[] objArray = new object[] { exception.ToString() };
unhandledException.Log("EXCEPTION thrown: {0}", objArray);
}
}
}
private IEnumerator <IAsyncResult> DeleteContainerImpl(IContainerCondition conditions, Guid?leaseId, AsyncIteratorContext <NoResults> context)
{
object obj;
IAsyncResult asyncResult;
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] timeout = new object[2];
object[] objArray = timeout;
obj = (leaseId.HasValue ? leaseId.ToString() : "<null>");
objArray[0] = obj;
timeout[1] = base.Timeout;
verboseDebug.Log("DeleteContainerImpl({0},{1})", timeout);
try
{
asyncResult = this.InternalContainer.BeginDeleteContainer(Helpers.Convert(conditions), leaseId, context.GetResumeCallback(), context.GetResumeState("BaseBlobContainer.DeleteBlobContainerImpl"));
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
yield return(asyncResult);
try
{
this.InternalContainer.EndDeleteContainer(asyncResult);
}
catch (Exception exception1)
{
StorageStamp.TranslateException(exception1);
throw;
}
}
private IEnumerator <IAsyncResult> CreateContainerImpl(DateTime?expiryTime, byte[] serviceMetadata, byte[] applicationMetadata, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult;
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { expiryTime, serviceMetadata, applicationMetadata, base.Timeout };
verboseDebug.Log("CreateContainerImpl({0},{1},{2},{3})", objArray);
try
{
asyncResult = this.InternalContainer.BeginCreateContainer(StorageStampHelpers.AdjustNullableDatetimeRange(expiryTime), serviceMetadata, applicationMetadata, context.GetResumeCallback(), context.GetResumeState("BaseBlobContainer.CreateContainerImpl"));
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
yield return(asyncResult);
try
{
this.InternalContainer.EndCreateContainer(asyncResult);
}
catch (Exception exception1)
{
StorageStamp.TranslateException(exception1);
throw;
}
}
private IEnumerator <IAsyncResult> DeleteTableContainerImpl(string tableName, IContainerCondition conditions, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult;
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { tableName, this.Timeout };
verboseDebug.Log("DeleteTableContainerImpl({0},{1})", objArray);
try
{
asyncResult = this.internalAccount.BeginDeleteTableContainer(tableName, Helpers.Convert(conditions), context.GetResumeCallback(), context.GetResumeState("StorageAccount.DeleteTableContainerImpl"));
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
yield return(asyncResult);
try
{
this.internalAccount.EndDeleteTableContainer(asyncResult);
}
catch (Exception exception1)
{
StorageStamp.TranslateException(exception1);
throw;
}
}
private IEnumerator <IAsyncResult> ListTableContainersImpl(string tableName, ContainerPropertyNames propertyNames, string separator, string tableNameStart, IContainerCondition condition, int maxContainerNames, AsyncIteratorContext <ITableContainerCollection> context)
{
IAsyncResult asyncResult;
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { tableName, propertyNames, separator, tableNameStart, condition, maxContainerNames, this.Timeout };
verboseDebug.Log("ListTableContainersImpl({0},{1},{2},{3},{4},{5},{6})", objArray);
try
{
asyncResult = this.internalAccount.BeginListTableContainers(tableName, propertyNames, separator, tableNameStart, Helpers.Convert(condition), maxContainerNames, context.GetResumeCallback(), context.GetResumeState("StorageStamp.ListTableContainersImpl"));
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
yield return(asyncResult);
try
{
ITableContainerCollection tableContainerCollections = this.internalAccount.EndListTableContainers(asyncResult);
context.ResultData = new TableContainerCollection(tableContainerCollections);
}
catch (Exception exception1)
{
StorageStamp.TranslateException(exception1);
throw;
}
}
private IEnumerator <IAsyncResult> DeleteQueueContainerImpl(string containerName, IContainerCondition conditions, AsyncIteratorContext <NoResults> context)
{
IStringDataEventStream verboseDebug = Logger <INormalAndDebugLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { containerName, this.Timeout };
verboseDebug.Log("DeleteQueueContainerImpl({0},{1})", objArray);
IAsyncResult asyncResult = this.StorageManager.AsyncProcessor.BeginExecute((TimeSpan param0) => {
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer queueContainer = new Microsoft.WindowsAzure.DevelopmentStorage.Store.QueueContainer()
{
AccountName = this._account.Name,
QueueName = containerName
};
queueContainer = DbQueueContainer.LoadQueueContainer(dbContext, queueContainer);
DbQueueContainer.CheckQueueContainerCondition(queueContainer, conditions);
dbContext.QueueContainers.DeleteOnSubmit(queueContainer);
dbContext.SubmitChanges();
}
}, this.Timeout, context.GetResumeCallback(), context.GetResumeState("StorageAccount.DeleteBlobContainerImpl"));
yield return(asyncResult);
this.StorageManager.AsyncProcessor.EndExecute(asyncResult);
}
private IEnumerator <IAsyncResult> SetPropertiesImpl(AccountPropertyNames propertyNames, IAccountCondition conditions, AsyncIteratorContext <NoResults> context)
{
IAsyncResult asyncResult;
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] objArray = new object[] { propertyNames, conditions, this.Timeout };
verboseDebug.Log("SetPropertiesImpl({0},{1},{2})", objArray);
try
{
asyncResult = this.internalAccount.BeginSetProperties(propertyNames, null, context.GetResumeCallback(), context.GetResumeState("StorageAccount.SetPropertiesImpl"));
}
catch (Exception exception)
{
StorageStamp.TranslateException(exception);
throw;
}
yield return(asyncResult);
try
{
this.internalAccount.EndSetProperties(asyncResult);
}
catch (Exception exception1)
{
StorageStamp.TranslateException(exception1);
throw;
}
}
public static bool LogUnhandledException(Exception e)
{
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] str = new object[] { e.ToString() };
error.Log("[FEUnhandledException] Process crashed due to fatal exception: {0}", str);
return(true);
}
private void ProcessPInvokeFailure(string methodName)
{
Win32Exception win32Exception = new Win32Exception();
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] objArray = new object[] { methodName, win32Exception.ErrorCode, win32Exception.NativeErrorCode, win32Exception.Message };
error.Log("{0} failed with ErrorCode = {1}, NativeErrorCode = {2} and Message = {3}.", objArray);
throw win32Exception;
}
private bool PutBlockList()
{
bool flag;
bool flag1 = false;
try
{
for (int i = 0; i < this._maxNumberOfRetries; i++)
{
try
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
using (DevelopmentStorageDbDataContext dbContext = DevelopmentStorageDbDataContext.GetDbContext())
{
this.GetContainer(dbContext);
BlockBlob blob = this.GetBlob(dbContext, true) as BlockBlob;
BlobServiceMetaData instance = BlobServiceMetaData.GetInstance(blob.ServiceMetadata);
instance.CopyStatus = "success";
instance.CopyProgressOffset = this._contentLength.ToString();
instance.CopyProgressTotal = this._contentLength.ToString();
instance.CopyCompletionTime = new long?(DateTime.UtcNow.ToFileTimeUtc());
blob.HasBlock = new bool?((this._blockIds.Count > 1 ? true : this._contentLength < (long)4194304));
blob.ContentLength = this._contentLength;
blob.ServiceMetadata = instance.GetMetadata();
blob.IsCommitted = new bool?(false);
blob.UncommittedBlockIdLength = null;
dbContext.SubmitChanges();
dbContext.CommitBlockList(this._accountName, this._containerName, this._blobName, DbListBlobObject.SerializeCommitBlockListEntryFromUncommitted(this._blockIds).ToString(), ref this._lastModifiedTime);
transactionScope.Complete();
}
}
IStringDataEventStream info = Logger <IRestProtocolHeadLogger> .Instance.Info;
object[] objArray = new object[] { this._accountName, this._containerName, this._blobName, this._contentLength };
info.Log("Commited Blocks for: {0}/{1}/{2}, Length:{3}", objArray);
break;
}
catch (SqlException sqlException)
{
if (this.ShouldRethrowException(i, sqlException, out flag1))
{
throw;
}
}
}
return(true);
}
catch (Exception exception1)
{
Exception exception = exception1;
Logger <IRestProtocolHeadLogger> .Instance.Error.Log("CopyBlob: PutBlockList exception {0}", new object[] { exception });
this.SetCopyFailed(exception, flag1, null);
flag = false;
}
return(flag);
}
public override void Write(string format)
{
IStringDataEventStream logger = (IStringDataEventStream)LoggerProvider.Instance.GetLogger(typeof(IStringDataEventStream), "LinqToSQL");
string[] strArrays = format.Split(new char[] { '\n' });
for (int i = 0; i < (int)strArrays.Length; i++)
{
logger.Log(strArrays[i]);
}
}
public static string MakeBlobDataCopy(BlockBlobMetaInfo blobInfo)
{
string str;
DevStoreBlockBlobFileParameters devStoreBlockBlobFileParameter = BlockBlobDataManager.AddInfoIfNotExists(blobInfo);
try
{
try
{
devStoreBlockBlobFileParameter.AccessReadWriteLock.EnterWriteLock();
string str1 = BlockBlobDataManager.CreateUniqueDirectoryLoadBalanced();
string[] files = Directory.GetFiles(devStoreBlockBlobFileParameter.DirectoryName);
string str2 = null;
IStringDataEventStream infoDebug = Logger <INormalAndDebugLogger> .Instance.InfoDebug;
object[] directoryName = new object[] { devStoreBlockBlobFileParameter.DirectoryName, str1 };
infoDebug.Log("BlockBlob: MakeBlobDataCopy SrcDir {0} -> DestDir {1}", directoryName);
if (files != null && (int)files.Length > 0)
{
string[] strArrays = files;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str3 = strArrays[i];
string str4 = Path.Combine(str1, Path.GetFileName(str3));
if (string.Compare(str3, devStoreBlockBlobFileParameter.ReadWriteFile, StringComparison.OrdinalIgnoreCase) == 0)
{
str2 = str4;
}
else
{
Logger <INormalAndDebugLogger> .Instance.InfoDebug.Log("BlockBlob: MakeBlobDataCopy SrcFile {0} -> DestFile {1}", new object[] { str3, str4 });
File.Copy(str3, str4);
}
}
IStringDataEventStream stringDataEventStream = Logger <INormalAndDebugLogger> .Instance.InfoDebug;
object[] readWriteFile = new object[] { devStoreBlockBlobFileParameter.ReadWriteFile, str2 };
stringDataEventStream.Log("BlockBlob: MakeBlobDataCopy RW FILE SrcFile {0} -> DestFile {1}", readWriteFile);
File.Copy(devStoreBlockBlobFileParameter.ReadWriteFile, str2);
}
str = str1;
}
catch (Exception exception1)
{
Exception exception = exception1;
Logger <INormalAndDebugLogger> .Instance.Error.Log("BlockBlob: MakeBlobDataCopy failed. Exception:{0}", new object[] { exception.StackTrace });
throw;
}
}
finally
{
devStoreBlockBlobFileParameter.AccessReadWriteLock.ExitWriteLock();
}
return(str);
}
public void UpdateFETimeBasedOnFinalServerProcessingTime(TimeSpan finalServerProcessingTime)
{
double totalMilliseconds = finalServerProcessingTime.TotalMilliseconds * 1000 - (double)this.TotalTableServerTimeInMicroSeconds - (double)this.TotalXStreamTimeInMicroSeconds - (double)((this.TotalPartitionWaitTimeInMs + this.TotalAccountCacheWaitTimeInMs + this.TotalContainerCacheWaitTimeInMs + this.TotalCustomEncryptionInfoCacheWaitTimeInMs + this.TotalXCacheTimeInMs) * (long)1000);
if (this.TotalTrackedTableServerTimeInMicroSeconds() != (long)0)
{
IStringDataEventStream verbose = Logger <IRestProtocolHeadLogger> .Instance.Verbose;
object[] objArray = new object[] { this.TotalTrackedTableServerTimeInMicroSeconds(), this.totalTableServerTimeInMicroSeconds, this.TotalCustomEncryptionInfoCacheWaitTimeInMs };
verbose.Log("TotalTrackedTableServerTimeInMicroSeconds: {0} totalTableServerTimeInMicroSeconds: {1} TotalCustomEncryptionInfoCacheWaitTimeInMs: {2}", objArray);
}
this.totalFETimeInMicroSeconds = (long)Math.Max(totalMilliseconds, 0);
}
private void SetCopyStatus(Blob blobObj)
{
if (this._currentLength < this._contentLength)
{
BlobServiceMetaData instance = BlobServiceMetaData.GetInstance(blobObj.ServiceMetadata);
instance.CopyProgressOffset = this._currentLength.ToString();
blobObj.ServiceMetadata = instance.GetMetadata();
}
IStringDataEventStream info = Logger <IRestProtocolHeadLogger> .Instance.Info;
object[] objArray = new object[] { this._accountName, this._containerName, this._blobName, this._currentLength, this._contentLength };
info.Log("CopyStatus for {0}/{1}/{2}: {3}B of {4}B", objArray);
}
private IEnumerator <IAsyncResult> FlushToInnerStreamImpl(TimeSpan timeout, AsyncIteratorContext <NoResults> context)
{
this.CheckDisposed();
Duration startingNow = Duration.StartingNow;
bool flag = true;
List <BufferWrapper> .Enumerator enumerator = this.buffers.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
byte[] numArray = enumerator.Current.Buffer;
if (this.bytesAccumulated == 0)
{
goto Label0;
}
int num = Math.Min((int)numArray.Length, this.bytesAccumulated);
int timeoutInMS = AsyncStreamCopy.TimeSpanToTimeoutInMS(startingNow.Remaining(timeout));
if (timeoutInMS == 0)
{
throw new TimeoutException("timed out while flushing");
}
if (flag)
{
try
{
this.innerStream.WriteTimeout = timeoutInMS;
}
catch (InvalidOperationException invalidOperationException)
{
flag = false;
}
}
IAsyncResult asyncResult = this.innerStream.BeginWrite(numArray, 0, num, context.GetResumeCallback(), context.GetResumeState("this.innerStream.Write"));
yield return(asyncResult);
this.innerStream.EndWrite(asyncResult);
IStringDataEventStream verbose = Logger <IRestProtocolHeadLogger> .Instance.Verbose;
verbose.Log("Finished flushing one block of data into underlying stream. Data bytes: {0}", new object[] { num });
this.bytesAccumulated -= num;
}
goto Label0;
throw new TimeoutException("timed out while flushing");
}
finally
{
((IDisposable)enumerator).Dispose();
}
Label0:
this.ResetBuffers();
}
public void Complete()
{
this.FinalTotalTime = this.OperationDuration.Elapsed;
if (this.TotalNonServerProcessingLatency <= this.FinalTotalTime)
{
this.FinalServerProcessingTime = this.FinalTotalTime.Subtract(this.TotalNonServerProcessingLatency);
return;
}
this.FinalServerProcessingTime = TimeSpan.Zero;
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] totalMilliseconds = new object[] { this.TotalNonServerProcessingLatency.TotalMilliseconds, this.FinalTotalTime.TotalMilliseconds, this.SmbOpLockBreakLatency.TotalMilliseconds };
error.Log("TotalNonServerProcessingLatency '{0}' exceeded FinalTotalTime '{1}' with SmbOpLockBreakLatency '{2}'", totalMilliseconds);
}
private void VerifyCrc(byte[] buffer, int offset, int count, long?crc)
{
if (crc.HasValue)
{
long num = CrcUtils.ComputeCrc(buffer, offset, count);
if (num != crc.Value)
{
throw new CrcMismatchException("Calculated CRC does not match Read CRC while streaming data to client", crc.Value, num, true);
}
IStringDataEventStream verbose = Logger <IRestProtocolHeadLogger> .Instance.Verbose;
object[] objArray = new object[] { count, num };
verbose.Log("Data CRC while streaming to client. Length:{0} CRC:0x{1:x}", objArray);
}
}
public static ConditionInformation GetConditionInfoFromRequest(NameValueCollection requestHeaders, OperationTypeForConditionParsing operationType, string requestVersion)
{
ConditionalHeaders conditionalHeadersFromRequest = ConditionExtractor.GetConditionalHeadersFromRequest(requestHeaders);
if (conditionalHeadersFromRequest == null)
{
return(null);
}
IStringDataEventStream info = Logger <IRestProtocolHeadLogger> .Instance.Info;
object[] ifModifiedSince = new object[] { conditionalHeadersFromRequest.IfModifiedSince ?? "<null>", conditionalHeadersFromRequest.IfUnmodifiedSince ?? "<null>", conditionalHeadersFromRequest.IfMatch ?? "<null>", conditionalHeadersFromRequest.IfNoneMatch ?? "<null>", conditionalHeadersFromRequest.IfRange ?? "<null>", conditionalHeadersFromRequest.CopySourceIfModifiedSince ?? "<null>", conditionalHeadersFromRequest.CopySourceIfUnmodifiedSince ?? "<null>", conditionalHeadersFromRequest.CopySourceIfMatch ?? "<null>", conditionalHeadersFromRequest.CopySourceIfNoneMatch ?? "<null>" };
info.Log("Conditional Headers:[IfModifiedSince = {0}, IfUnmodifiedSince = {1}, IfMatch = {2}, IfNoneMatch = {3}, IfRange = {4}, CopySourceIfModifiedSince = {5}, CopySourceIfUnmodifiedSince = {6}, CopySourceIfMatch = {7}, CopySourceIfNoneMatch = {8}]", ifModifiedSince);
return(MultipleConditionExtractor.ExecuteExtractors(conditionalHeadersFromRequest, requestHeaders, operationType, requestVersion, MultipleConditionExtractor.Extractors));
}
public override void AcceptRequest(RequestContext context, Microsoft.Cis.Services.Nephos.Common.ServiceType serviceType)
{
Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug.Log("Accepting request");
context.ServiceType = serviceType;
PerRequestStorageManager perRequestStorageManager = new PerRequestStorageManager(BlobServiceEntry.SharedStorageManager, context.OperationStatus);
AuthenticationManager operationStatus = XFEBlobAuthenticationManager.CreateAuthenticationManager(perRequestStorageManager, false);
operationStatus.OperationStatus = context.OperationStatus;
AuthorizationManager authorizationManager = XFEBlobAuthorizationManager.CreateAuthorizationManager(perRequestStorageManager, true);
authorizationManager.OperationStatus = context.OperationStatus;
ServiceManager serviceManager = RealServiceManager.CreateServiceManager(authorizationManager, perRequestStorageManager, BlobServiceEntry.SharedConfig);
serviceManager.OperationStatus = context.OperationStatus;
IProcessor processor = HttpRestProcessor.Create(context, perRequestStorageManager, operationStatus, serviceManager, HttpRestProcessor.HttpProcessorConfigurationDefaultInstance, new TransformExceptionDelegate(SqlExceptionManager.TransformSqlException), null);
bool flag = true;
try
{
try
{
processor.BeginProcess(new AsyncCallback(this.ProcessAsyncCallback), processor);
flag = false;
}
catch (NephosAssertionException nephosAssertionException1)
{
NephosAssertionException nephosAssertionException = nephosAssertionException1;
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] str = new object[] { nephosAssertionException.ToString() };
error.Log("ASSERTION in BeginProcess: {0}", str);
}
catch (Exception exception1)
{
Exception exception = exception1;
IStringDataEventStream unhandledException = Logger <IRestProtocolHeadLogger> .Instance.UnhandledException;
object[] objArray = new object[] { exception.ToString() };
unhandledException.Log("BeginProcess threw exception {0}", objArray);
}
}
finally
{
if (flag)
{
processor.Dispose();
}
}
Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug.Log("Returning from AcceptRequest method.");
}
public void SetUserTimeout(TimeSpan userTimeout, TimeSpan maxAllowedTimeout)
{
if (userTimeout > maxAllowedTimeout)
{
IStringDataEventStream verbose = Logger <IRestProtocolHeadLogger> .Instance.Verbose;
object[] totalMilliseconds = new object[] { (long)userTimeout.TotalMilliseconds, (long)maxAllowedTimeout.TotalMilliseconds };
verbose.Log("Limiting user timeout '{0}'ms to max allowed timeout '{1}ms'.", totalMilliseconds);
userTimeout = maxAllowedTimeout;
}
this.UserTimeout = userTimeout;
if (this.OperationTimeout == TimeSpan.MaxValue)
{
this.OperationTimeout = userTimeout;
}
}
protected override IEnumerator <IAsyncResult> GetMessagesImpl(IAccountIdentifier identity, string account, string queue, int numMessages, long?visibilityTimeout, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <IEnumerable <PoppedMessage> > context)
{
object obj;
this.ValidateNumMessages(numMessages, this.config.MaxMessagesToReturn);
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Process
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.ReadDelete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetMessagesImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
long?nullable = visibilityTimeout;
obj = (nullable.HasValue ? nullable.GetValueOrDefault() : this.config.DefaultVisibilityTimeoutSeconds);
TimeSpan timeSpan = TimeSpan.FromSeconds((double)obj);
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginGetMessage(numMessages, timeSpan, context.GetResumeCallback(), context.GetResumeState("QueueManager.GetMessagesImpl"));
yield return(asyncResult);
IEnumerable <IMessageData> messageDatas = operationStatus.EndGetMessage(asyncResult);
StringBuilder stringBuilder = new StringBuilder();
context.ResultData = this.WrapGetMessageResults(messageDatas);
int num = 0;
foreach (PoppedMessage resultDatum in context.ResultData)
{
stringBuilder.Append(string.Format("[{0}],", resultDatum.ToString()));
num++;
}
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] str = new object[] { num, stringBuilder.ToString() };
verboseDebug.Log("GetMessages response: Count={0} Messages={1}", str);
}
public CrcMismatchException(string message, long specifiedCrc, long calculatedCrc, bool isCriticalError, Exception innerException) : base(message, innerException)
{
this.SpecifiedCrc = specifiedCrc;
this.CalculatedCrc = calculatedCrc;
this.IsCriticalError = isCriticalError;
if (isCriticalError)
{
TimeSpan?nullable = null;
AlertsManager.AlertOrLogException(string.Format("Hit CrcMismatchException with message:{0} SpecifiedCrc:{1} CalculatedCrc:{2}", message, specifiedCrc, calculatedCrc), message, nullable);
return;
}
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] objArray = new object[] { message, specifiedCrc, calculatedCrc };
error.Log("Hit CrcMismatchException with message:{0} SpecifiedCrc:{1} CalculatedCrc:{2}", objArray);
}
protected override IEnumerator <IAsyncResult> DeleteMessageImpl(IAccountIdentifier identity, string account, string queue, string messageId, byte[] popReceipt, TimeSpan?timeout, RequestContext requestContext, AsyncIteratorContext <NoResults> context)
{
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Process
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
NephosAssertionException.Assert(popReceipt != null);
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Delete, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteMessageImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
try
{
Guid guid = new Guid(messageId);
}
catch (Exception exception)
{
throw new MessageNotFoundException("Invalid message name", exception);
}
IQueueMessageReceipt queueMessageReceipt = this.DecodeReceipt(popReceipt, new Guid(messageId));
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginDeleteMessage(queueMessageReceipt, context.GetResumeCallback(), context.GetResumeState("QueueManager.DeleteMessageImpl"));
yield return(asyncResult);
bool flag = operationStatus.EndDeleteMessage(asyncResult);
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
object[] str = new object[] { flag, queueMessageReceipt.ToString() };
verboseDebug.Log("DeleteMessage response: status={0} message={1}", str);
if (!flag)
{
throw new MessageNotFoundException("The message could not be deleted or pop receipt invalid.");
}
}
public static void AlertOrLogException(Exception e, string alertMessage = null, string alertKey = null, TimeSpan?alertIntervalOverride = null)
{
if (AlertsManager.ShouldAlertForException(e))
{
if (AlertsManager.ShouldSendAlert(alertKey ?? e.GetType().ToString(), alertIntervalOverride))
{
IStringDataEventStream critical = Logger <IRestProtocolHeadLogger> .Instance.Critical;
object[] objArray = new object[] { alertMessage ?? "[FEUnhandledException] An unexpected non-fatal exception was encountered", e.ToString() };
critical.Log("{0}: {1}", objArray);
return;
}
}
IStringDataEventStream error = Logger <IRestProtocolHeadLogger> .Instance.Error;
object[] objArray1 = new object[] { alertMessage ?? "[FEUnhandledException] An unexpected non-fatal exception was encountered", e.ToString() };
error.Log("{0}: {1}", objArray1);
}
protected override IEnumerator <IAsyncResult> PutMessageImpl(IAccountIdentifier identity, string account, string queue, List <PushedMessage> messagesList, TimeSpan?timeout, RequestContext requestContext, bool usePutMessageRowCommand, AsyncIteratorContext <IEnumerable <PoppedMessage> > context)
{
TimeSpan timeSpan;
RemainingTime remainingTime = new RemainingTime(timeout);
SASAuthorizationParameters sASAuthorizationParameter = new SASAuthorizationParameters()
{
SupportedSasTypes = SasType.ResourceSas | SasType.AccountSas,
SignedResourceType = SasResourceType.Object,
SignedPermission = SASPermission.Add
};
SASAuthorizationParameters sASAuthorizationParameter1 = sASAuthorizationParameter;
IAsyncResult asyncResult = this.BeginGetQueue(identity, account, queue, PermissionLevel.Write, sASAuthorizationParameter1, remainingTime, requestContext, context.GetResumeCallback(), context.GetResumeState("QueueManager.PutMessageImpl"));
yield return(asyncResult);
IQueueContainer operationStatus = this.EndGetQueue(asyncResult);
if (requestContext != null)
{
operationStatus.OperationStatus = requestContext.OperationStatus;
}
object obj = messagesList;
if (obj == null)
{
obj = Enumerable.Empty <PushedMessage>();
}
foreach (PushedMessage pushedMessage in (IEnumerable <PushedMessage>)obj)
{
PushedMessage nullable = pushedMessage;
TimeSpan? messageTTL = pushedMessage.MessageTTL;
timeSpan = (messageTTL.HasValue ? messageTTL.GetValueOrDefault() : TimeSpan.FromSeconds((double)this.config.MaxTtlSeconds));
nullable.MessageTTL = new TimeSpan?(timeSpan);
}
operationStatus.Timeout = remainingTime;
asyncResult = operationStatus.BeginPutMessage(messagesList, usePutMessageRowCommand, context.GetResumeCallback(), context.GetResumeState("QueueManager.PutMessageImpl"));
yield return(asyncResult);
List <IMessageData> messageDatas = operationStatus.EndPutMessage(asyncResult);
context.ResultData = this.WrapGetMessageResults(messageDatas);
IStringDataEventStream verboseDebug = Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug;
verboseDebug.Log("PutMessage response: MessageId={0}", new object[] { context.ResultData });
}
