async Task <SourcedState> LoadSourcedStateFromScratch()
{
SourcedState state = new SourcedState();
if (!await file.ExistsAsync())
{
return(state);
}
var records = await GetAllAsync();
var dict = new Dictionary <long, RecordContainer>();
foreach (var e in records)
{
dict[e.VersionId] = e;
}
if (dict.Count > 0)
{
state.AddNewRecords(dict);
}
return(state);
}
public static async void UploadErrorLogs()
{
var TaskA = new System.Threading.Tasks.Task(async() =>
{
pathcre();
try
{
sc = new StorageCredentials("icsintegration", "+7UyQSwTkIfrL1BvEbw5+GF2Pcqh3Fsmkyj/cEqvMbZlFJ5rBuUgPiRR2yTR75s2Xkw5Hh9scRbIrb68GRCIXA==");
storageaccount = new CloudStorageAccount(sc, true);
blobClient = storageaccount.CreateCloudBlobClient();
container = blobClient.GetContainerReference("userlogs");
await container.CreateIfNotExistsAsync(); //{
append = container.GetAppendBlobReference(userid + ".csv"); //}
if (!await append.ExistsAsync())
{
await append.CreateOrReplaceAsync();
}
}
catch (Exception exe)
{
Log.Error("Error", exe.Message);
}
});
TaskA.Start();
}
public CloudAppendBlob GetCloudBlob(CloudStorageAccount storageAccount, string folderName, string fileName, bool bypassBlobCreationValidation)
{
if (cloudAppendBlob != null)
{
return(cloudAppendBlob);
}
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer cloudBlobContainer = cloudBlobClient.GetContainerReference(folderName);
try
{
cloudBlobContainer.CreateIfNotExistsAsync().SyncContextSafeWait(waitTimeoutMilliseconds);
cloudAppendBlob = cloudBlobContainer.GetAppendBlobReference(fileName);
if (!cloudAppendBlob.ExistsAsync().Result)
{
cloudAppendBlob.CreateOrReplaceAsync().Wait();
}
}
catch (Exception ex)
{
Debugging.SelfLog.WriteLine($"Failed to create blob container: {ex}");
if (!bypassBlobCreationValidation)
{
throw;
}
}
return(cloudAppendBlob);
}
/// <summary>
/// Log the event to persistent store
/// </summary>
/// <param name="username">username of the caller</param>
/// <param name="message">message from the caller</param>
private static async void Persist(string username, string message)
{
string accountKey = Environment.GetEnvironmentVariable("AccountKey");
string accountName = Environment.GetEnvironmentVariable("AccountName");
// Implement the accout, set true for https for SSL.
StorageCredentials creds = new StorageCredentials(accountName, accountKey);
CloudStorageAccount strAcc = new CloudStorageAccount(creds, true);
CloudBlobClient blobClient = strAcc.CreateCloudBlobClient();
// Setup our container we are going to use and create it.
CloudBlobContainer container = blobClient.GetContainerReference("logs");
await container.CreateIfNotExistsAsync();
// Build my typical log file name.
DateTime date = DateTime.Today;
DateTime dateLogEntry = DateTime.Now;
// This creates a reference to the append blob we are going to use.
CloudAppendBlob appBlob = container.GetAppendBlobReference(
string.Format("{0}{1}", date.ToString("yyyyMMdd"), ".log"));
// Now we are going to check if todays file exists and if it doesn't we create it.
if (!await appBlob.ExistsAsync())
{
await appBlob.CreateOrReplaceAsync();
}
// Add the entry to our log.
await appBlob.AppendTextAsync($"{dateLogEntry.ToString("o")}-{username}-{message}\r\n");
}
public async Task UploadFile(string sourcePath, string sourceFilename, string containerName, string targetFilename, string contentType, bool append = false)
{
byte[] fileContent = File.ReadAllBytes(Path.Join(fixPath(sourcePath), sourceFilename));
CloudStorageAccount account = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient serviceClient = account.CreateCloudBlobClient();
var container = serviceClient.GetContainerReference(getContainerName(containerName));
container.CreateIfNotExistsAsync().Wait();
CloudAppendBlob blob = container.GetAppendBlobReference(getFilepathForContainer(containerName, targetFilename));
if (!append)
{
await blob.CreateOrReplaceAsync();
}
else
{
if (!blob.ExistsAsync().Result)
{
throw new Exception($"Cannot append to nonexistent blob file {sourceFilename}");
}
}
blob.Properties.ContentType = contentType;
await blob.AppendTextAsync(fileContent.ToString());
}
private async Task CheckBloksCountAsync()
{
if (!_blob.Properties.AppendBlobCommittedBlockCount.HasValue)
{
await _blob.FetchAttributesAsync();
}
if (_blob.Properties.AppendBlobCommittedBlockCount.Value < _maxBlocksCount)
{
return;
}
int i = 1;
while (true)
{
var fileName = $"{_blob.Name}--{i:00}";
_blob = _blobContainer.GetAppendBlobReference(fileName);
bool exists = await _blob.ExistsAsync();
if (!exists)
{
break;
}
++i;
}
_log.WriteInfo("BlobSaver.CheckBloksCountAsync", _container, $"Created additional blob - {_blob.Name}");
await InitBlobPropertiesAsync();
}
/// <summary>
/// Gets the content from blob.
/// </summary>
/// <param name="blobName">Name of blob</param>
/// <returns>csv data as string</returns>
public async Task <string> GetContentAsync(string blobName)
{
string appendBlobContent = null;
try
{
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(configuration.GetConnectionString("AzureStorage"));
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
CloudBlobContainer cloudBlobContainer = cloudBlobClient.GetContainerReference(configuration.GetConnectionString("ContainerName"));
CloudAppendBlob cloudAppendBlob = cloudBlobContainer.GetAppendBlobReference(blobName);
if (await cloudAppendBlob.ExistsAsync())
{
appendBlobContent = await cloudAppendBlob.DownloadTextAsync();
}
else
{
appendBlobContent = await GetZipAsync(blobName);
}
return(appendBlobContent);
}
catch (Exception)
{
return(appendBlobContent);
}
}
public static void CreateIfNotExists(this CloudAppendBlob blob)
{
if (blob.ExistsAsync().Result)
{
blob.CreateOrReplaceAsync().Wait();
}
}
public static async void UploadAsyncLogs(string log)
{
try
{
//pathcre();
//Console.WriteLine(log);
if (userid == "0" || userid == "DefaultLogs")
{
if (CurrentUser.GetGuestId() == "0" || CurrentUser.GetGuestId() == null)
{
userid = "DefaultLogs";
}
else
{
userid = "g_" + CurrentUser.GetGuestId();
}
}
CloudAppendBlob append = container.GetAppendBlobReference(userid + ".csv");
Console.WriteLine("User id " + userid + " ");
Console.WriteLine(log);
if (!await append.ExistsAsync())
{
await append.CreateOrReplaceAsync();
}
await append.AppendTextAsync(log);
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message);
}
}
public async Task Test_31_Blob_withInfiniteLease()
{
CloudBlobContainer cbc = _Client.GetContainerReference("test-append-blob-container");
await cbc.CreateIfNotExistsAsync();
CloudAppendBlob blob = cbc.GetAppendBlobReference("test-append-blob-withlease2.data");
var blobExists = await blob.ExistsAsync();
if (!blobExists)
{
await blob.CreateOrReplaceAsync();
}
string data = string.Empty.PadLeft(64 * 1024, '*');
string leaseIdGuid = Guid.NewGuid().ToString();
var oc = new OperationContext();
var ac = new AccessCondition();
var leaseID = await blob.AcquireLeaseAsync(null, leaseIdGuid, ac, null, null);
ac.LeaseId = leaseID;
try
{
for (int ix = 0; ix < 10; ix++)
{
await blob.AppendTextAsync(data, null, ac, null, oc);
}
}
finally
{
await blob.ReleaseLeaseAsync(ac, null, oc);
}
}
private static async Task <List <FileRecord> > ReadStreamToRecords(CloudAppendBlob blob)
{
List <FileRecord> records = new List <FileRecord>();
using (var s = new MemoryStream())
{
if (!await blob.ExistsAsync())
{
return(records);
}
await blob.DownloadRangeToStreamAsync(s, 0, blob.Properties.Length);
s.Position = 0;
var reader = new BinaryReader(s);
var record = new FileRecord();
while (record.ReadContentFromStream(reader))
{
records.Add(record);
record = new FileRecord();
}
}
return(records);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
string name = req.Query["name"];
try
{
log.LogInformation("C# HTTP trigger function processed a request.");
var StorageURL = Environment.GetEnvironmentVariable("StorageURL");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
name = name ?? data?.name;
var azureServiceTokenProvider = new AzureServiceTokenProvider();
string accessToken = await azureServiceTokenProvider.GetAccessTokenAsync("https://storage.azure.com");
log.LogInformation("accessToken : retrieved");
// create the credential, using the
var tokenCredential = new Microsoft.WindowsAzure.Storage.Auth.TokenCredential(accessToken);
var storageCredentials = new StorageCredentials(tokenCredential);
log.LogInformation("credentials : created");
var fileName = "append";
var Uri = new Uri(StorageURL + fileName);
var blob = new CloudAppendBlob(Uri, storageCredentials);
log.LogInformation($"blobfile : setup {0}", Uri);
if (!(await blob.ExistsAsync()))
{
await blob.CreateOrReplaceAsync(AccessCondition.GenerateIfNotExistsCondition(), null, null);
}
await blob.AppendTextAsync(name);
var fileName2 = "regular.txt";
var Uri2 = new Uri(StorageURL + fileName2);
var blob2 = new CloudBlockBlob(Uri2, storageCredentials);
await blob2.UploadTextAsync(name);
}
catch (Exception ex)
{
log.LogInformation($"EXEC {ex.ToString()} ");
}
return(name != null
? (ActionResult) new OkObjectResult($"Hello, {name}")
: new BadRequestObjectResult("Please pass a name on the query string or in the request body"));
}
public async Task WriteLog(ILog log, CloudBlobContainer container = null)
{
try
{
if (container == null)
{
container = await GetCloudBlobLogsContainer(LOGS_KEY);
}
var path = this.GetCloudContainerLogPath(log.LogType);
var dir = container.GetDirectoryReference(path);
var file = DateTime.Now.Hour.ToString("00") + "00.log";
string json = JsonConvert.SerializeObject(log, JSON.SerializationSettings);
// Note: AppendBlockBlob is not available in the Storage Emulator/Explorer
if (GetCloudConnectionString(LOGS_KEY) == "UseDevelopmentStorage=true")
{
CloudBlockBlob blob = dir.GetBlockBlobReference(file);
try
{
await blob.UploadTextAsync(json);
}
catch (StorageException ex)
{
}
catch (Exception ex)
{
}
}
else
{
CloudAppendBlob blob = dir.GetAppendBlobReference(DateTime.Now.Hour.ToString("00") + "00.log");
if (!(await blob.ExistsAsync()))
{
try
{
await blob.CreateOrReplaceAsync(AccessCondition.GenerateIfNotExistsCondition(), null, null);
}
catch (StorageException ex)
{
}
catch (Exception ex)
{
}
}
using (var stream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(json)))
{
await blob.AppendBlockAsync(stream);
}
}
}
catch (StorageException ex)
{
}
catch (Exception ex)
{
}
}
private async static void AcquireLeaseDemo()
{
try
{
string name = "LeaseDemo/text-0221e06e5e254fb3bb0bf0e37d9d0e32.txt";
CloudBlobContainer container = _cloudBlobClient.GetContainerReference("text-files");
await container.CreateIfNotExistsAsync();
CloudAppendBlob cloudAppendBlob = container.GetAppendBlobReference(name);
bool shouldContinue = true;
if (await cloudAppendBlob.ExistsAsync())
{
if (cloudAppendBlob.Properties.LeaseStatus == LeaseStatus.Locked)
{
shouldContinue = false;
Console.WriteLine("Blob is currently in lease");
}
else
{
await cloudAppendBlob.CreateOrReplaceAsync();
}
}
if (shouldContinue)
{
string proposedLeaseId = Guid.NewGuid().ToString("n");
AccessCondition accessCondition = new AccessCondition();
OperationContext operationContext = new OperationContext();
Console.WriteLine("Acquiring lock...");
string leaseId = await cloudAppendBlob.AcquireLeaseAsync(null, proposedLeaseId, accessCondition, null, operationContext);
accessCondition.LeaseId = leaseId;
try
{
Console.WriteLine("Uploading text...");
for (int i = 0; i <= 50; i++)
{
await cloudAppendBlob.AppendTextAsync($"{Guid.NewGuid().ToString("n")}{Environment.NewLine}", UTF8Encoding.UTF8, accessCondition, null, operationContext);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
await cloudAppendBlob.ReleaseLeaseAsync(accessCondition, null, operationContext);
Console.WriteLine("Process finished. Lock has been released");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
/// <summary>
/// Delivers blob information like length, lastmodified, etag
/// </summary>
/// <returns></returns>
public async Task <BlobProperties> GetBlobProperties()
{
if (await blob.ExistsAsync())
{
await blob.FetchAttributesAsync();
return(blob.Properties);
}
return(null);
}
private async Task <int> UploadToAzureStorage(String messageString)
{
try
{
// create Azure Storage
CloudStorageAccount storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=norkartstorageaccount;AccountKey=ywvq9KDDK/F1mqiz1NJ/vEj9lT7wuVrEqWtO1f3hi+i4vw9gOCvJG1rOjVKpjx/Ki1q6rVjG7uUalT+hWdXxCA==");
// create a blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
// create a container
CloudBlobContainer container = blobClient.GetContainerReference("norkartstorageaccount");
CloudAppendBlob appBlob = container.GetAppendBlobReference("Temperature&Humidity/" + DateTime.Now.ToString("yyyy-dd-M") + ".json");
//CloudAppendBlob appBlob = container.GetAppendBlobReference("TestFile.txt");
System.Diagnostics.Debug.WriteLine("APPBLOB EXISTS: " + appBlob.ExistsAsync().Result.ToString());
if (appBlob.ExistsAsync().Result.ToString() != "True")
{
await appBlob.CreateOrReplaceAsync();
}
// create a local file
//StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(DateTime.Now.ToString("yyyy-dd-M--HH-mm-ss"), CreationCollisionOption.GenerateUniqueName);
//StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync("TestFile.txt", CreationCollisionOption.GenerateUniqueName);
await appBlob.AppendTextAsync(messageString + Environment.NewLine);
return(1);
}
catch
{
// return error
System.Diagnostics.Debug.WriteLine("STORAGE ERROR");
return(0);
}
}
//获取blob数据
public static async Task <string> GetBlobConent(string blobName, CloudBlobContainer blobContainer)
{
CloudAppendBlob blob = blobContainer.GetAppendBlobReference($"{(object)blobName}.json");
bool flag = await blob.ExistsAsync();
if (flag)
{
return(await blob.DownloadTextAsync());
}
else
{
return("");
}
}
private async Task SendBufferAsync(LoggingEvent[] events)
{
CloudAppendBlob appendBlob = _cloudBlobContainer.GetAppendBlobReference(Filename(_directoryName));
if (!await appendBlob.ExistsAsync().ConfigureAwait(false))
{
await appendBlob.CreateOrReplaceAsync().ConfigureAwait(false);
}
else
{
_lineFeed = Environment.NewLine;
}
await Task.WhenAll(events.Select(ProcessEvent));
}
private async Task <CloudAppendBlob> GetBlobAsync(DateTime eventTime)
{
string tagName = eventTime.ToString("yyyy-MM-dd");
if (tagName != _currentTagName)
{
_currentTagName = tagName;
_appendBlob = _blobContainer.GetAppendBlobReference($"{_blobNamePrefix}{_currentTagName}.txt");
if (!(await _appendBlob.ExistsAsync()))
{
await _appendBlob.CreateOrReplaceAsync();
}
}
return(_appendBlob);
}
public static async void UploadErrorLogs()
{
pathcre();
try
{
sc = new StorageCredentials("icsintegration", "+7UyQSwTkIfrL1BvEbw5+GF2Pcqh3Fsmkyj/cEqvMbZlFJ5rBuUgPiRR2yTR75s2Xkw5Hh9scRbIrb68GRCIXA==");
storageaccount = new CloudStorageAccount(sc, true);
blobClient = storageaccount.CreateCloudBlobClient();
container = blobClient.GetContainerReference("userlogs");
//var csv = new StringBuilder();
//var newLine = string.Format("Exception", DateTime.Now, "Test", "Test", "Test");
//csv.AppendLine(newLine);
//File.AppendAllText(logspath, csv.ToString());
await container.CreateIfNotExistsAsync();
//CloudBlockBlob blob = container.GetBlockBlobReference(CurrentUser.getUserId() + ".csv"); //(path);
//if (CurrentUser.getUserId() == null)
//{
append = container.GetAppendBlobReference(userid + ".csv");
//}
//else
//{
// append = container.GetAppendBlobReference(CurrentUser.getUserId() + ".csv");
//}
if (!await append.ExistsAsync())
{
await append.CreateOrReplaceAsync();
}
//await append.AppendBlockAsync("aksfhgaUKGdfkAUSFDAUSGFD");
//await append.UploadTextAsync(string.Format("Exception,Test,Test,Test"));
//await append.AppendTextAsync( string.Format("Exception,Test1,Test1,Test1 "+"\n"));
//await append.AppendTextAsync(string.Format("{0},{1},{2},{3},{4}", "Exception", DateTime.Now, lineno, screenid + "\n"));
//using (var fs = System.IO.File.Open(path, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.None))
// {
// await blob.UploadFromStreamAsync(fs);
// }
}
catch (Exception exe)
{
Log.Error("Error", exe.Message);
}
}
public static async Task WriteStateToBlob(CloudBlobContainer blobContainer, string blobName, string content)
{
CloudAppendBlob appendBlob = blobContainer.GetAppendBlobReference($"{(object)blobName}.json");
bool flag = await appendBlob.ExistsAsync();
if (!flag)
{
await appendBlob.CreateOrReplaceAsync();
}
appendBlob.Properties.ContentType = "application/json";
using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(content)))
{
stream.Position = 0;
await appendBlob.UploadFromStreamAsync(stream);
}
}
public async Task Test_30_Blob_InfiniteLease()
{
// Containers are like folders
CloudBlobContainer container = _client.GetContainerReference("test-append-blob-container");
await container.CreateIfNotExistsAsync();
// Blobs are like files
CloudAppendBlob blob = container.GetAppendBlobReference("test-append-blob-with-lease");
var blobExists = await blob.ExistsAsync();
if (!blobExists)
{
await blob.CreateOrReplaceAsync();
}
string data = string.Empty.PadLeft(64 * 1024, '*');
string leaseId = Guid.NewGuid().ToString();
var operationContext = new OperationContext();
var accessCondition = new AccessCondition();
// For pessimistic access control
// Acquire lease
var leaseID = await blob.AcquireLeaseAsync(null, leaseId, accessCondition, null, operationContext);
accessCondition.LeaseId = leaseID;
try
{
// Make modifications based on that lease
for (int i = 0; i < 1000; i++)
{
await blob.AppendTextAsync(data, null, accessCondition, null, operationContext);
}
}
finally
{
// And finally release that lease
await blob.ReleaseLeaseAsync(accessCondition, null, operationContext);
}
}
public async Task DownloadFile(string targetPath, string targetFilename, string sasUri, bool append = false)
{
string targetFullPath = Path.Join(fixPath(targetPath), targetFilename);
CloudAppendBlob blob = new CloudAppendBlob(new Uri(sasUri));
if (!append)
{
await blob.DownloadToFileAsync(targetFullPath, FileMode.Create);
}
else
{
if (!blob.ExistsAsync().Result)
{
throw new Exception($"Cannot download nonexistent blob file {targetFilename}");
}
await blob.DownloadToFileAsync(targetFullPath, FileMode.Append);
}
}
public static void UploadNewText()
{
Console.Write("Please enter text to add to the blob: ");
string text = Console.ReadLine();
//file name
string fileName = "test.csv";
CloudAppendBlob blob = container.GetAppendBlobReference(fileName);
//Create new blob file, if it does not exist.
if (blob.ExistsAsync().Result == false)
{
blob.CreateOrReplaceAsync();
}
//Append text to the end of data.
blob.AppendTextAsync(text);
}
} // End of the DeleteByLastModifiedDate method
#endregion
#region Helper methods
/// <summary>
/// Append text to an append blob
/// </summary>
private async Task WriteToAppendBlob(string blob_name, string log)
{
// Get a blob reference
CloudAppendBlob blob = this.container.GetAppendBlobReference(blob_name);
// Create a blob if it doesn't exist
if (await blob.ExistsAsync() == false)
{
await blob.CreateOrReplaceAsync();
}
// Append the log to a blob
using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(log)))
{
// Append text to the blob
await blob.AppendBlockAsync(stream);
}
} // End of the WriteToAppendBlob method
public async Task UploadFile(string sourcePath, string sourceFilename, string sasUri, string contentType, bool append = false)
{
byte[] fileContent = File.ReadAllBytes(Path.Join(fixPath(sourcePath), sourceFilename));
CloudAppendBlob blob = new CloudAppendBlob(new Uri(sasUri));
if (!append)
{
await blob.CreateOrReplaceAsync();
}
else
{
if (!blob.ExistsAsync().Result)
{
throw new Exception($"Cannot append to nonexistent blob file {sourceFilename}");
}
}
blob.Properties.ContentType = contentType;
await blob.AppendTextAsync(fileContent.ToString());
}
private void Roll()
{
_day = DateTime.Now;
string stamp = _day.ToString("yyyy-MM-dd");
string blobName = $"{_baseBlobName}_{stamp}.log";
_blob = _container.GetAppendBlobReference(blobName);
if (!_blob.ExistsAsync().Result)
{
_blob.CreateOrReplaceAsync().Wait();
_blob.FetchAttributesAsync().Wait();
_blob.Metadata["Day"] = stamp;
_blob.Metadata["Name"] = _baseBlobName;
_blob.SetMetadataAsync().Wait();
}
}
//获取blob数据
public static async Task <string> GetBlobConent(string blobName, CloudBlobContainer blobContainer)
{
CloudAppendBlob blob = blobContainer.GetAppendBlobReference($"{(object)blobName}.json");
bool flag = await blob.ExistsAsync();
bool exist = flag;
string str1;
if (exist)
{
string str2 = await blob.DownloadTextAsync();
object obj = (object)str2;
str1 = $"[{obj}]";
}
else
{
str1 = "";
}
return(str1);
}
//public async Task WriteBlockBlobAsync(string containerName, string filename,
// byte[] source, string contentType, CancellationToken token = default(CancellationToken))
//{
// if (source == null)
// {
// throw new ArgumentNullException("source");
// }
// CloudBlobContainer container = await GetContainerReferenceAsync(containerName);
// CloudBlockBlob blob = container.GetBlockBlobReference(filename);
// blob.Properties.ContentType = contentType;
// await UploadAsync(blob, source, token);
//}
public async Task WriteAppendBlobAsync(string containerName, string filename, byte[] source, string contentType = "application/octet-stream", CancellationToken token = default(CancellationToken))
{
if (source == null)
{
throw new ArgumentNullException("source");
}
CloudBlobContainer container = await GetContainerReferenceAsync(containerName);
CloudAppendBlob blob = container.GetAppendBlobReference(filename);
if (!await blob.ExistsAsync())
{
blob.Properties.ContentType = contentType;
await UploadAsync(blob, source, token);
}
else
{
await blob.AppendFromByteArrayAsync(source, 0, source.Length);
}
}
protected override void Write(LogEventInfo logEvent)
{
_client = _client ?? CloudStorageAccount.Parse(ConnectionString.Render(logEvent)).CreateCloudBlobClient();
if (_client == null)
{
return;
}
var containerName = Container.Render(logEvent);
var blobName = BlobName.Render(logEvent);
if (_container == null || _container.Name != containerName)
{
_container = _client.GetContainerReference(containerName);
_container.CreateIfNotExistsAsync().Wait();
_blob = null;
}
if (_blob == null || _blob.Name != blobName || _forceCheck)
{
_blob = _container.GetAppendBlobReference(blobName);
if (!_blob.ExistsAsync().Result)
{
try
{
_blob.Properties.ContentType = "text/plain";
_blob.CreateOrReplaceAsync().Wait();
_blob.SetPropertiesAsync().Wait();
}
catch (StorageException ex) when(ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.Conflict)
{
// to be expected
}
}
}
_blob.AppendTextAsync(Layout.Render(logEvent) + "\r\n").Wait();
}
