public virtual void Init()
{
var client = CloudStorageAccount.DevelopmentStorageAccount.CreateCloudTableClient();
_table = client.GetTableReference("kalixleotablequery");
_table.CreateIfNotExists();
_table.Execute(TableOperation.InsertOrReplace(BuildEntity("test1", "test1")));
_table.Execute(TableOperation.InsertOrReplace(BuildEntity("test1", "test2")));
_table.Execute(TableOperation.InsertOrReplace(BuildEntity("test2", "test1")));
_table.Execute(TableOperation.InsertOrReplace(BuildEntity("test2", "test2")));
_query = new AzureTableQuery<TestEntity>(_table, null);
}
private void CopyEntity(DynamicTableEntity entity, CloudTable destTable)
{
ConsoleWrite.Verbose(" Copying {0} / {1}", entity.PartitionKey, entity.RowKey);
if (_args.IsReal)
{
var operation = TableOperation.Insert(entity);
destTable.Execute(operation);
}
}
private static void InsertSession(CloudTable table)
{
//Create some data to store
var session = CreateSession();
// Create the TableOperation object that inserts the session entity.
var insertOperation = TableOperation.Insert(session);
// Execute the insert operation.
table.Execute(insertOperation);
}
// Used to fetch an existing container entry so we can append it.
public static Task<ContainerActiveEntity> LookupAsync(CloudTable table, long timeBucket, string containerName)
{
TableOperation retrieveOperation = TableOperation.Retrieve<ContainerActiveEntity>(
TableScheme.ContainerActivePK,
RowKeyTimeInterval(timeBucket, containerName));
// Execute the retrieve operation.
TableResult retrievedResult = table.Execute(retrieveOperation);
var x = (ContainerActiveEntity)retrievedResult.Result;
return Task.FromResult(x);
}
private static void Search2(CloudTable table)
{
TableOperation retrieveOperation = TableOperation.Retrieve<CustomerEntity>("Harp", "Ben");
// Execute the retrieve operation.
TableResult retrievedResult = table.Execute(retrieveOperation);
// Print the phone number of the result.
if (retrievedResult.Result != null)
Console.WriteLine(((CustomerEntity)retrievedResult.Result).PhoneNumber);
else
Console.WriteLine("The phone number could not be retrieved.");
}
public DashboardUpdate(CloudTable generalInfoTable, CloudTable pageTable, CloudTable errorTable, CloudTable mappingTable, CloudQueue urlQ)
{
this.dashboardTable = generalInfoTable;
this.pageTable = pageTable;
this.errorTable = errorTable;
this.mappingTable = mappingTable;
this.urlQ = urlQ;
IEnumerator<Dashboard> results = generalInfoTable.ExecuteQuery(new TableQuery<Dashboard>()).GetEnumerator();
if (!results.MoveNext())
{
generalInfoTable.Execute(TableOperation.InsertOrReplace(new Dashboard(0, 0, 0, new List<string>(), new List<string>())));
}
}
public void Setup()
{
this.storageAccount = CloudStorageAccount.DevelopmentStorageAccount;
this.tableClient = storageAccount.CreateCloudTableClient();
this.table1 = tableClient.GetTableReference("table1");
this.table1.DeleteIfExists();
this.table1.Create();
var entityToCreate = new TestEntity()
{
ID = "1",
FirstName = "Cecil",
LastName = "Cedar"
};
entityToCreate.PartitionKey = entityToCreate.LastName;
entityToCreate.RowKey = entityToCreate.ID;
var op = TableOperation.Insert(entityToCreate);
table1.Execute(op);
}
public static void Initialize(TestContext context)
{
ConnectionStringSettingsCollection settings =
ConfigurationManager.ConnectionStrings;
ConnectionStringSettings connectionStringSettings = settings["Azure"];
var builder = new DbConnectionStringBuilder
{
ConnectionString = connectionStringSettings.ConnectionString
};
accountName = (string) builder["AccountName"];
accountKey = (string) builder["AccountKey"];
var account = CloudStorageAccount.Parse(connectionStringSettings.ConnectionString);
CloudTableClient tableClient = account.CreateCloudTableClient();
// Create Table
table = tableClient.GetTableReference(TableName);
var b = table.DeleteIfExists();
Console.WriteLine(string.Format("deleted table {0}: {1}", TableName, b));
table.CreateIfNotExists();
// Insert Entity
var person = new ContactEntity("Peter", "Ritchie") { Email = "*****@*****.**", PhoneNumber = "555-0123" };
table.Execute(TableOperation.Insert(person));
}
public void CloudTableSASWithAbsoluteUri()
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference(tableClient.BaseUri + GenerateRandomTableName());
try
{
table.CreateIfNotExists();
BaseEntity entity = new BaseEntity("PK", "RK");
table.Execute(TableOperation.Insert(entity));
SharedAccessTablePolicy policy = new SharedAccessTablePolicy()
{
Permissions = SharedAccessTablePermissions.Delete,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(10)
};
string sasToken = table.GetSharedAccessSignature(policy);
StorageCredentials creds = new StorageCredentials(sasToken);
CloudTable sasTable = new CloudTable(table.Uri, creds);
sasTable.Execute(TableOperation.Delete(entity));
}
finally
{
table.DeleteIfExists();
}
}
private void CalculateMADataToAzure(CloudTable table, string azureTableStockCode, int MA)
{
DateTime startingDate = DateTime.FromFileTimeUtc(0);
TableOperation retrieveStockEntityStatus = TableOperation.Retrieve<StockEntityStatus>("status-" + azureTableStockCode, "status");
var stockEntityStatus = (StockEntityStatus)table.Execute(retrieveStockEntityStatus).Result;
if (stockEntityStatus != null)
{
startingDate = stockEntityStatus.GetLatestMAStartDate(MA);
Console.WriteLine("Latest starting date for MA{0} is on {1}", MA, startingDate.ToString("yyyy-MM-dd"));
}
string pkFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, azureTableStockCode);
string rkLowerFilter = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, startingDate.ToString("yyyy-MM-dd"));
string combinedFilter = TableQuery.CombineFilters(pkFilter, TableOperators.And, rkLowerFilter);
TableQuery<StockEntity> query = new TableQuery<StockEntity>().Where(combinedFilter);
var sortedStockEntities = table.ExecuteQuery<StockEntity>(query).OrderBy(entity => entity.Date).ToList();
if (sortedStockEntities.LongCount() >= MA)
{
long totalCountToUpload = sortedStockEntities.LongCount();
long currentCountUploaded = 0;
Queue<double> maData = new Queue<double>();
TableBatchOperation tableBatchOperation = new TableBatchOperation();
foreach (var stockEntity in sortedStockEntities)
{
maData.Enqueue(stockEntity.Close);
if (maData.Count == MA)
{
double sum = 0;
foreach (var data in maData)
{
sum += data;
}
stockEntity.SetMA(MA, sum / MA);
tableBatchOperation.Add(TableOperation.InsertOrMerge(stockEntity));
maData.Dequeue();
}
if (tableBatchOperation.Count == 100)
{
table.ExecuteBatch(tableBatchOperation);
currentCountUploaded += 100;
Console.WriteLine("{0}/{1} entities uploaded...", currentCountUploaded, totalCountToUpload);
tableBatchOperation.Clear();
}
}
if (tableBatchOperation.Count > 0)
{
table.ExecuteBatch(tableBatchOperation);
currentCountUploaded += tableBatchOperation.Count;
Console.WriteLine("{0}/{1} entities uploaded...", currentCountUploaded, totalCountToUpload);
}
sortedStockEntities.Reverse();
if (sortedStockEntities == null)
{
stockEntityStatus = new StockEntityStatus(azureTableStockCode);
}
stockEntityStatus.SetLatestMAStartDate(MA, sortedStockEntities[MA - 2].Date);
table.Execute(TableOperation.InsertOrMerge(stockEntityStatus));
}
}
private void DoEscapeTest(string data, bool useBatch, bool includeKey)
{
DynamicTableEntity ent = new DynamicTableEntity(includeKey ? "temp" + data : "temp", Guid.NewGuid().ToString());
ent.Properties.Add("foo", new EntityProperty(data));
// Insert
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Insert(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Insert(ent));
}
// Retrieve
TableResult res = null;
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
// Check equality
DynamicTableEntity retrievedEntity = res.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Query using data filter
TableQuery query = new TableQuery();
query.Where(string.Format(
"(PartitionKey eq \'{0}\') and (RowKey eq \'{1}\') and (foo eq \'{2}\')",
ent.PartitionKey,
ent.RowKey,
data.Replace("\'", "\'\'")));
retrievedEntity = currentTable.ExecuteQuery(query).Single();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Merge
ent.Properties.Add("foo2", new EntityProperty("bar2"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Merge(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Merge(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Replace
ent.Properties.Remove("foo2");
ent.Properties.Add("foo3", new EntityProperty("bar3"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Replace(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Replace(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
}
public TableResult InsertEntity(CloudTable table, TableEntity entity)
{
TableOperation insertOperation = TableOperation.Insert(entity);
return table.Execute(insertOperation);
}
/// <summary>
/// Finds an existing login.
/// </summary>
/// <param name="loginTable">the login table.</param>
/// <param name="accountId">the account id.</param>
/// <returns>A matching entity or null.</returns>
private static LoginEntity FindExistingLogin(
CloudTable loginTable,
EmailAddress accountId)
{
TableOperation findExistingOperation = TableOperation.Retrieve<LoginEntity>(
accountId.Domain,
accountId.LocalPart);
TableResult findExistingResult = loginTable.Execute(findExistingOperation);
return findExistingResult.Result as LoginEntity;
}
// Writes to Azure Table Storage
// Note: Azure Table Storage will not write records that are longer than 64Kb
public static void WriteToBlobStorageTable(WindowsAzureTable.CloudTable cloudTable, string category, string documentName, string ocrResult,
string keyPhraseResult, string distinctKeyPhraseString,
string entities, string distinctEntitiesString,
int pages, string uri, string documentType, long documentSizeInBytes,
PIIResult piiResultV2, List <CognitiveServiceClasses.PII.Entity> piiResultV3,
List <BingEntityData> bingEntityDataResult,
SentimentV3Response sentimentV3Prediction,
CognitiveServicesApiCalls cognitiveServicesApiCalls)
{
ocrResult = ocrResult.Trim();
keyPhraseResult = keyPhraseResult.Trim();
var entityTaxonomies =
(bingEntityDataResult is null) ? string.Empty :
string.Join(" ;;;; ", bingEntityDataResult.Select(a => a.Taxony).ToArray());
var size = ocrResult.Length * sizeof(char);
var keyPhraseResultSize = keyPhraseResult.Length * sizeof(char);
var distinctKeyPhraseResultSize = distinctKeyPhraseString.Length * sizeof(char);
var entitiesSize = entities.Length * sizeof(char);
var entityTaxonomiesSize = entityTaxonomies.Length * sizeof(char);
// Only for Table Storage API (CosmosDB can handle large values)
if (size > 63999)
{
var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * ocrResult.Length, 0));
ocrResult = ocrResult.Substring(0, Math.Min(ocrResult.Length, lengthToTake));
}
if (keyPhraseResultSize > 31999)
{
var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * keyPhraseResult.Length, 0));
keyPhraseResult = keyPhraseResult.Substring(0, Math.Min(keyPhraseResult.Length, lengthToTake));
}
if (distinctKeyPhraseResultSize > 31999)
{
var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * distinctKeyPhraseString.Length, 0));
distinctKeyPhraseString = keyPhraseResult.Substring(0, Math.Min(distinctKeyPhraseString.Length, lengthToTake));
}
if (entitiesSize > 31999)
{
var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * entities.Length, 0));
entities = keyPhraseResult.Substring(0, Math.Min(entities.Length, lengthToTake));
}
if (entityTaxonomiesSize > 31999)
{
var lengthToTake = Convert.ToInt32(Math.Round((double)(32000 * 1.0 / size) * entityTaxonomies.Length, 0));
entityTaxonomies = keyPhraseResult.Substring(0, Math.Min(entityTaxonomies.Length, lengthToTake));
}
// Create a new customer entity.
var document = new DocumentEntity(category, documentName);
document.CognitiveServicesApiCallsApiCallCount = cognitiveServicesApiCalls.ApiCallCount;
document.CognitiveServicesApiCallsApiCallV2Count = cognitiveServicesApiCalls.ApiCallV2Count;
document.CognitiveServicesApiCallsApiCallV3Count = cognitiveServicesApiCalls.ApiCallV3Count;
document.CognitiveServicesApiCallsTotalCount = cognitiveServicesApiCalls.TotalCount;
document.OcrResult = ocrResult.Trim();
document.TextAnalyticsKeyPhraseResult = keyPhraseResult;
document.TextAnalyticsDistinctKeyPhraseResult = distinctKeyPhraseString;
document.TextAnalyticsEntitiesResult = entities;
document.TextAnalyticsDistinctEntititesResult = new string(distinctEntitiesString.Take(31999).ToArray());
document.TextAnalyticsEntitiesTaxonomiesResult = entityTaxonomies;
document.TextSize = size;
document.Pages = pages;
document.Uri = uri;
document.DocumentType = documentType;
document.DocumentSizeInBytes = documentSizeInBytes;
if (piiResultV2.Addresses != null)
{
document.PIIEmailsCount = piiResultV2.Emails.Count;
document.PIIAddressesCount = piiResultV2.Addresses.Count;
document.PIIPhoneNumbersCount = piiResultV2.PhoneNumbers.Count;
document.PIISSNSCount = piiResultV2.SSNs.Count;
}
if (sentimentV3Prediction.Documents != null)
{
document.SentimentAnalysis =
"Positive: " + sentimentV3Prediction.Documents[0].DocumentScores.Positive +
", Neutral: " + sentimentV3Prediction.Documents[0].DocumentScores.Neutral +
", Negative: " + sentimentV3Prediction.Documents[0].DocumentScores.Negative;
}
// Create the TableOperation object that inserts the customer entity.
var insertOperation = WindowsAzureTable.TableOperation.InsertOrReplace(document);
// Execute the insert operation.
cloudTable.Execute(insertOperation);
}
public PageInfo getWebpageInfo()
{
mappingTable = Azure.GetInstance().getTableReference("mappingtable");
webpageInfo.title = "";
HtmlNode node = root.SelectSingleNode("//title");
if (node != null)
{
webpageInfo.title = node.InnerText;
}
string title = webpageInfo.title;
string[] keywords = title.Split(' ');
try
{
foreach (string keyword in keywords)
{
mappingTable.Execute(TableOperation.Insert(new Mapping(keyword, url)));
}
}
catch (StorageException) { }
string datetime = null;
node = root.SelectSingleNode("//meta[@http-equiv='last-modified']");
if (node != null)
{
datetime = node.GetAttributeValue("content", null);
}
else
{
node = root.SelectSingleNode("//meta[@name='date']");
if (node != null)
{
datetime = node.GetAttributeValue("content", null);
}
else
{
Match match = Regex.Match(html, @"<div>Posted:\s*[^<]+\s*;\s*Updated:\s*([^<]+)\s*</div>");
if (match.Success)
{
datetime = match.Groups[1].Value;
}
else
{
match = Regex.Match(html, @"<div>Posted:\s*([^<]+)\s*</div>");
if (match.Success)
{
datetime = match.Groups[1].Value;
}
}
}
}
try
{
webpageInfo.date = DateTime.Parse(datetime);
}
catch (ArgumentNullException)
{
Trace.TraceInformation("Datetime not fetched for url: " + webpageInfo.url);
throw new WebParseDatetimeException();
}
catch (FormatException)
{
Trace.TraceInformation("Datetime not parsable: " + datetime);
throw new WebParseDatetimeException();
}
return webpageInfo;
}
public void CloudTableSASSharedProtocolsQueryParam()
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N"));
try
{
table.Create();
SharedAccessTablePolicy policy = new SharedAccessTablePolicy()
{
Permissions = SharedAccessTablePermissions.Query,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
DynamicTableEntity entity = new DynamicTableEntity("PK", "RK", null, new Dictionary<string, EntityProperty>() { { "prop", new EntityProperty(4) } });
table.Execute(new TableOperation(entity, TableOperationType.Insert));
foreach (SharedAccessProtocol? protocol in new SharedAccessProtocol?[] { null, SharedAccessProtocol.HttpsOrHttp, SharedAccessProtocol.HttpsOnly })
{
string tableToken = table.GetSharedAccessSignature(policy, null, null, null, null, null, protocol, null);
StorageCredentials tableSAS = new StorageCredentials(tableToken);
Uri tableSASUri = new Uri(table.Uri + tableSAS.SASToken);
StorageUri tableSASStorageUri = new StorageUri(new Uri(table.StorageUri.PrimaryUri + tableSAS.SASToken), new Uri(table.StorageUri.SecondaryUri + tableSAS.SASToken));
int httpPort = tableSASUri.Port;
int securePort = 443;
if (!string.IsNullOrEmpty(TestBase.TargetTenantConfig.TableSecurePortOverride))
{
securePort = Int32.Parse(TestBase.TargetTenantConfig.TableSecurePortOverride);
}
var schemesAndPorts = new[] {
new { scheme = Uri.UriSchemeHttp, port = httpPort},
new { scheme = Uri.UriSchemeHttps, port = securePort}
};
CloudTable tableWithSAS = null;
TableOperation retrieveOp = TableOperation.Retrieve(entity.PartitionKey, entity.RowKey);
foreach (var item in schemesAndPorts)
{
tableSASUri = TransformSchemeAndPort(tableSASUri, item.scheme, item.port);
tableSASStorageUri = new StorageUri(TransformSchemeAndPort(tableSASStorageUri.PrimaryUri, item.scheme, item.port), TransformSchemeAndPort(tableSASStorageUri.SecondaryUri, item.scheme, item.port));
if (protocol.HasValue && protocol.Value == SharedAccessProtocol.HttpsOnly && string.CompareOrdinal(item.scheme, Uri.UriSchemeHttp) == 0)
{
tableWithSAS = new CloudTable(tableSASUri);
TestHelper.ExpectedException(() => tableWithSAS.Execute(retrieveOp), "Access a table using SAS with a shared protocols that does not match", HttpStatusCode.Unused);
tableWithSAS = new CloudTable(tableSASStorageUri, null);
TestHelper.ExpectedException(() => tableWithSAS.Execute(retrieveOp), "Access a table using SAS with a shared protocols that does not match", HttpStatusCode.Unused);
}
else
{
tableWithSAS = new CloudTable(tableSASUri);
TableResult result = tableWithSAS.Execute(retrieveOp);
Assert.AreEqual(entity.Properties["prop"], ((DynamicTableEntity)result.Result).Properties["prop"]);
tableWithSAS = new CloudTable(tableSASStorageUri, null);
result = tableWithSAS.Execute(retrieveOp);
Assert.AreEqual(entity.Properties["prop"], ((DynamicTableEntity)result.Result).Properties["prop"]);
}
}
}
}
finally
{
table.DeleteIfExists();
}
}
public void TableSasUriPkRkTestSync()
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N"));
try
{
table.Create();
SharedAccessTablePolicy policy = new SharedAccessTablePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessTablePermissions.Add,
};
string sasTokenPkRk = table.GetSharedAccessSignature(policy, null, "tables_batch_0", "00",
"tables_batch_1", "04");
StorageCredentials credsPkRk = new StorageCredentials(sasTokenPkRk);
// transform uri from credentials
CloudTable sasTableTransformed = new CloudTable(credsPkRk.TransformUri(table.Uri));
// create uri by appending sas
CloudTable sasTableDirect = new CloudTable(new Uri(table.Uri.ToString() + sasTokenPkRk));
BaseEntity pkrkEnt = new BaseEntity("tables_batch_0", "00");
sasTableTransformed.Execute(TableOperation.Insert(pkrkEnt));
pkrkEnt = new BaseEntity("tables_batch_0", "01");
sasTableDirect.Execute(TableOperation.Insert(pkrkEnt));
Action<BaseEntity, CloudTable, OperationContext> insertDelegate = (tableEntity, sasTable1, ctx) =>
{
sasTable1.Execute(TableOperation.Insert(tableEntity), null, ctx);
};
pkrkEnt = new BaseEntity("tables_batch_2", "00");
TestHelper.ExpectedException(
(ctx) => insertDelegate(pkrkEnt, sasTableTransformed, ctx),
string.Format("Inserted entity without appropriate SAS permissions."),
(int)HttpStatusCode.Forbidden);
TestHelper.ExpectedException(
(ctx) => insertDelegate(pkrkEnt, sasTableDirect, ctx),
string.Format("Inserted entity without appropriate SAS permissions."),
(int)HttpStatusCode.Forbidden);
pkrkEnt = new BaseEntity("tables_batch_1", "05");
TestHelper.ExpectedException(
(ctx) => insertDelegate(pkrkEnt, sasTableTransformed, ctx),
string.Format("Inserted entity without appropriate SAS permissions."),
(int)HttpStatusCode.Forbidden);
TestHelper.ExpectedException(
(ctx) => insertDelegate(pkrkEnt, sasTableDirect, ctx),
string.Format("Inserted entity without appropriate SAS permissions."),
(int)HttpStatusCode.Forbidden);
}
finally
{
table.DeleteIfExists();
}
}
public void TableUpdateSasTestSync()
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N"));
try
{
table.Create();
BaseEntity entity = new BaseEntity("PK", "RK");
table.Execute(TableOperation.Insert(entity));
SharedAccessTablePolicy policy = new SharedAccessTablePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessTablePermissions.Delete,
};
string sasToken = table.GetSharedAccessSignature(policy);
StorageCredentials creds = new StorageCredentials(sasToken);
CloudTable sasTable = new CloudTable(table.Uri, creds);
TestHelper.ExpectedException(
() => sasTable.Execute(TableOperation.Insert(new BaseEntity("PK", "RK2"))),
"Try to insert an entity when SAS doesn't allow inserts",
HttpStatusCode.Forbidden);
sasTable.Execute(TableOperation.Delete(entity));
SharedAccessTablePolicy policy2 = new SharedAccessTablePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessTablePermissions.Delete | SharedAccessTablePermissions.Add,
};
string sasToken2 = table.GetSharedAccessSignature(policy2);
creds.UpdateSASToken(sasToken2);
sasTable = new CloudTable(table.Uri, creds);
sasTable.Execute(TableOperation.Insert(new BaseEntity("PK", "RK2")));
}
finally
{
table.DeleteIfExists();
}
}
public void ProcessTweetBlob(CloudBlockBlob inputBlob, CloudTable outputAzureTable, string folder)
{
int count = 0;
List<TweetSentimentScore> scores = new List<TweetSentimentScore>();
using (var reader = new CsvReader(new StreamReader(inputBlob.OpenRead())))
{
while (reader.Read())
{
if (count == 0)
{
logger.Write(TraceEventType.Information, "First line: [{0}]", string.Join(",", reader.CurrentRecord));
}
count++;
var tweet = reader.GetField(0); //get the tweet
var entity = new TweetSentimentScore()
{
PartitionKey = "tweetsentimentscore",
RowKey = Guid.NewGuid().ToString(),
Tweet = tweet,
SentimentScore = GetScore(url, email, apikey, tweet)
};
scores.Add(entity);
outputAzureTable.Execute(TableOperation.InsertOrReplace(entity)); //Do it one row at a time for demo output
}
}
var iter = scores.Count() / 100;
for (int i = 0; i <= iter; i++)
{
var batchOp = new TableBatchOperation();
scores.Skip(100 * i).Take(100).ToList().ForEach(a =>
{
batchOp.Add(TableOperation.InsertOrReplace(a));
});
//outputAzureTable.ExecuteBatch(batchOp); //Removed for demo purposes.
}
logger.Write(TraceEventType.Information, string.Format(CultureInfo.InvariantCulture,
"{0},{1},{2},{3},{4}\n",
folder,
inputBlob.Name,
count,
Environment.MachineName,
DateTime.UtcNow));
}
/// <summary>
/// Finds an existing organization by name.
/// </summary>
/// <param name="table">the organization table.</param>
/// <param name="name">the organization name.</param>
/// <returns>The matching entity or null.</returns>
private static OrganizationEntity FindExistingOrganization(
CloudTable table,
string name)
{
TableOperation findExistingOperation = TableOperation.Retrieve<OrganizationEntity>(
name,
string.Empty);
TableResult findExistingResult = table.Execute(findExistingOperation);
return findExistingResult.Result as OrganizationEntity;
}
// Azure Blobにデータを追加
// POST api/blobadd/{UserID名}/{Module名}
public string Post(string fir, string sec, [FromBody]BlobAdd blobadd) {
// RDBの中からターゲットモジュールなどの検索
var user = RDB.db.Users.Where(p => p.idName.Equals(fir)).Single();
var module = user.Modules.Where(p => p.Name.Equals(sec)).Single();
var units = module.Units;
// パスワードチェック(ハッシュ関数込み)
if (!(module.wPassWord == null)) {
string HashPW = common.GetHashPassword(blobadd.dataaddlist[0].dt, sec, module.wPassWord);
try {
if (!(blobadd.dataaddlist[0].pw.Equals(HashPW))) {
return "PassWord error";
}
} catch {
return "You need to password";
}
}
try {
// データ挿入中はTypeプロパティは"2"
module.Type = "2";
RDB.db.SaveChanges();
// もし、データ種類の設定を事前に行っていなければ、初期設定をする
if (units.Count == 0) {
Unit unit = new Unit();
unit.Unit1 = "File Name";
unit.TypeDataId = 12;
unit.Modules.Add(module);
RDB.db.SaveChanges();
units = module.Units;
}
string time = common.GetTimeIndex(blobadd.dataaddlist[0].dt);
// Table内には、モジュールIDとBlobデータ格納時刻とファイル名が入る
#region Insert AzureTable
table = common.AzureAccess();
DataEntity customer1 = new DataEntity("Take," + module.id, time);
customer1.DataVal = "BlobData";
TableOperation insertOperationTake = TableOperation.Insert(customer1);
table.Execute(insertOperationTake);
DataEntity customer2 = new DataEntity("Value," + module.id, time + "," + units.FirstOrDefault().id);
customer2.DataVal = blobadd.filename;
TableOperation insertOperationValue = TableOperation.Insert(customer2);
table.Execute(insertOperationValue);
#endregion
// Blob内には、送信されたデータ全てをSONテキストとして1行に格納される
#region Insert AzureBlob
JavaScriptSerializer serializer = new JavaScriptSerializer();
string json = serializer.Serialize(blobadd);
CloudBlobContainer container = common.BlobAccess();
CloudBlockBlob blockBlob = container.GetBlockBlobReference(module.id.ToString() + "," + time);
blockBlob.UploadText(json);
blockBlob.Properties.ContentType = "application/JSON";
blockBlob.SetProperties();
#endregion
module.Latest = blobadd.dataaddlist[0].dt;
module.NumData += 1;
} catch {
module.Type = "0";
RDB.db.SaveChanges();
}
module.Type = "0";
RDB.db.SaveChanges();
return "Success!";
}
public void TableSasUriTestSync()
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N"));
try
{
table.Create();
BaseEntity entity = new BaseEntity("PK", "RK");
BaseEntity entity1 = new BaseEntity("PK", "RK1");
table.Execute(TableOperation.Insert(entity));
table.Execute(TableOperation.Insert(entity1));
SharedAccessTablePolicy policy = new SharedAccessTablePolicy()
{
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
Permissions = SharedAccessTablePermissions.Delete,
};
string sasToken = table.GetSharedAccessSignature(policy);
StorageCredentials creds = new StorageCredentials(sasToken);
CloudStorageAccount sasAcc = new CloudStorageAccount(creds, null /* blobEndpoint */, null /* queueEndpoint */, new Uri(TestBase.TargetTenantConfig.TableServiceEndpoint), null /* fileEndpoint */);
CloudTableClient client = sasAcc.CreateCloudTableClient();
CloudTable sasTable = new CloudTable(client.Credentials.TransformUri(table.Uri));
sasTable.Execute(TableOperation.Delete(entity));
CloudTable sasTable2 = new CloudTable(new Uri(table.Uri.ToString() + sasToken));
sasTable2.Execute(TableOperation.Delete(entity1));
}
finally
{
table.DeleteIfExists();
}
}
/// <summary>
/// Finds an existing application with the given name.
/// </summary>
/// <param name="table">the applications table.</param>
/// <param name="name">the name of the app.</param>
/// <returns>The application entity or null if the application does not exist.</returns>
private static ApplicationEntity FindExistingApplication(CloudTable table, string name)
{
TableOperation findOperation = TableOperation.Retrieve<ApplicationEntity>(name, string.Empty);
TableResult result = table.Execute(findOperation);
return result.Result as ApplicationEntity;
}
/// <summary>
/// Helper function for testing the IPAddressOrRange funcitonality for tables
/// </summary>
/// <param name="generateInitialIPAddressOrRange">Function that generates an initial IPAddressOrRange object to use. This is expected to fail on the service.</param>
/// <param name="generateFinalIPAddressOrRange">Function that takes in the correct IP address (according to the service) and returns the IPAddressOrRange object
/// that should be accepted by the service</param>
public void CloudTableSASIPAddressHelper(Func<IPAddressOrRange> generateInitialIPAddressOrRange, Func<IPAddress, IPAddressOrRange> generateFinalIPAddressOrRange)
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N"));
try
{
table.Create();
SharedAccessTablePolicy policy = new SharedAccessTablePolicy()
{
Permissions = SharedAccessTablePermissions.Query,
SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5),
SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30),
};
DynamicTableEntity entity = new DynamicTableEntity("PK", "RK", null, new Dictionary<string, EntityProperty>() {{"prop", new EntityProperty(4)}});
table.Execute(new TableOperation(entity, TableOperationType.Insert));
// The plan then is to use an incorrect IP address to make a call to the service
// ensure that we get an error message
// parse the error message to get my actual IP (as far as the service sees)
// then finally test the success case to ensure we can actually make requests
IPAddressOrRange ipAddressOrRange = generateInitialIPAddressOrRange();
string tableToken = table.GetSharedAccessSignature(policy, null, null, null, null, null, null, ipAddressOrRange);
StorageCredentials tableSAS = new StorageCredentials(tableToken);
Uri tableSASUri = tableSAS.TransformUri(table.Uri);
StorageUri tableSASStorageUri = tableSAS.TransformUri(table.StorageUri);
CloudTable tableWithSAS = new CloudTable(tableSASUri);
OperationContext opContext = new OperationContext();
IPAddress actualIP = null;
bool exceptionThrown = false;
TableResult result = null;
DynamicTableEntity resultEntity = new DynamicTableEntity();
TableOperation retrieveOp = new TableOperation(resultEntity, TableOperationType.Retrieve);
retrieveOp.RetrievePartitionKey = entity.PartitionKey;
retrieveOp.RetrieveRowKey = entity.RowKey;
try
{
result = tableWithSAS.Execute(retrieveOp, null, opContext);
}
catch (StorageException e)
{
string[] parts = e.RequestInformation.HttpStatusMessage.Split(' ');
actualIP = IPAddress.Parse(parts[parts.Length - 1].Trim('.'));
exceptionThrown = true;
Assert.IsNotNull(actualIP);
}
Assert.IsTrue(exceptionThrown);
ipAddressOrRange = generateFinalIPAddressOrRange(actualIP);
tableToken = table.GetSharedAccessSignature(policy, null, null, null, null, null, null, ipAddressOrRange);
tableSAS = new StorageCredentials(tableToken);
tableSASUri = tableSAS.TransformUri(table.Uri);
tableSASStorageUri = tableSAS.TransformUri(table.StorageUri);
tableWithSAS = new CloudTable(tableSASUri);
resultEntity = new DynamicTableEntity();
retrieveOp = new TableOperation(resultEntity, TableOperationType.Retrieve);
retrieveOp.RetrievePartitionKey = entity.PartitionKey;
retrieveOp.RetrieveRowKey = entity.RowKey;
resultEntity = (DynamicTableEntity)tableWithSAS.Execute(retrieveOp).Result;
Assert.AreEqual(entity.Properties["prop"].PropertyType, resultEntity.Properties["prop"].PropertyType);
Assert.AreEqual(entity.Properties["prop"].Int32Value.Value, resultEntity.Properties["prop"].Int32Value.Value);
Assert.IsTrue(table.StorageUri.PrimaryUri.Equals(tableWithSAS.Uri));
Assert.IsNull(tableWithSAS.StorageUri.SecondaryUri);
tableWithSAS = new CloudTable(tableSASStorageUri, null);
resultEntity = new DynamicTableEntity();
retrieveOp = new TableOperation(resultEntity, TableOperationType.Retrieve);
retrieveOp.RetrievePartitionKey = entity.PartitionKey;
retrieveOp.RetrieveRowKey = entity.RowKey;
resultEntity = (DynamicTableEntity)tableWithSAS.Execute(retrieveOp).Result;
Assert.AreEqual(entity.Properties["prop"].PropertyType, resultEntity.Properties["prop"].PropertyType);
Assert.AreEqual(entity.Properties["prop"].Int32Value.Value, resultEntity.Properties["prop"].Int32Value.Value);
Assert.IsTrue(table.StorageUri.Equals(tableWithSAS.StorageUri));
}
finally
{
table.DeleteIfExists();
}
}
public void send_to_builder()
{
string[] arr = new string[100];
arr = rd1.Split('-');
var date = DateTime.Now;
table = tableClient.GetTableReference("builder");
try
{
if (table.CreateIfNotExists())
{
Console.Write("builder" + " Table ");
Console.WriteLine("Created ");
}
else
{
Console.WriteLine("builder" + " Table not created");
}
}
catch (StorageException s)
{
Console.WriteLine("Refresh and retry " + s.ToString());
return;
}
BuilderEntity bd = new BuilderEntity(arr[2],arr[6]);
bd.buildername = arr[1];
bd.contactnumber = arr[5];
bd.customername = arr[3];
bd.location = arr[4];
TableOperation insertOperation = TableOperation.Insert(bd);
// Execute the insert operation.
try
{
table.Execute(insertOperation);
Console.WriteLine(arr[2]+" "+ arr[6] + " Record Inserted");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void TableSASNullAccessPolicy()
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N"));
try
{
table.Create();
table.Execute(TableOperation.Insert(new BaseEntity("PK", "RK")));
TablePermissions expectedPermissions = new TablePermissions();
// Add a policy
expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy
{
Permissions = SharedAccessTablePermissions.Query | SharedAccessTablePermissions.Add,
SharedAccessStartTime = DateTimeOffset.Now - TimeSpan.FromHours(1),
SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromHours(1)
});
table.SetPermissions(expectedPermissions);
Thread.Sleep(30 * 1000);
// Generate the sasToken the user should use
string sasToken = table.GetSharedAccessSignature(null, expectedPermissions.SharedAccessPolicies.First().Key, "AAAA", null, "AAAA", null);
CloudTable sasTable = new CloudTable(table.Uri, new StorageCredentials(sasToken));
sasTable.Execute(TableOperation.Insert(new DynamicTableEntity("AAAA", "foo")));
TableResult result = sasTable.Execute(TableOperation.Retrieve("AAAA", "foo"));
Assert.IsNotNull(result.Result);
// revoke table permissions
table.SetPermissions(new TablePermissions());
Thread.Sleep(30 * 1000);
OperationContext opContext = new OperationContext();
try
{
sasTable.Execute(TableOperation.Insert(new DynamicTableEntity("AAAA", "foo2")), null, opContext);
Assert.Fail();
}
catch (Exception)
{
Assert.AreEqual(opContext.LastResult.HttpStatusCode, (int)HttpStatusCode.Forbidden);
}
opContext = new OperationContext();
try
{
result = sasTable.Execute(TableOperation.Retrieve("AAAA", "foo"), null, opContext);
Assert.Fail();
}
catch (Exception)
{
Assert.AreEqual(opContext.LastResult.HttpStatusCode, (int)HttpStatusCode.Forbidden);
}
}
finally
{
table.DeleteIfExists();
}
}
public void TableSASNullAccessPolicy()
{
CloudTableClient tableClient = GenerateCloudTableClient();
CloudTable table = tableClient.GetTableReference("T" + Guid.NewGuid().ToString("N"));
try
{
table.Create();
table.Execute(TableOperation.Insert(new BaseEntity("PK", "RK")));
TablePermissions expectedPermissions = new TablePermissions();
// Add a policy
expectedPermissions.SharedAccessPolicies.Add(Guid.NewGuid().ToString(), new SharedAccessTablePolicy
{
Permissions = SharedAccessTablePermissions.Query | SharedAccessTablePermissions.Add,
SharedAccessStartTime = DateTimeOffset.Now - TimeSpan.FromHours(1),
SharedAccessExpiryTime = DateTimeOffset.Now + TimeSpan.FromHours(1)
});
table.SetPermissions(expectedPermissions);
Thread.Sleep(30 * 1000);
// Generate the sasToken the user should use
string sasToken = table.GetSharedAccessSignature(null, expectedPermissions.SharedAccessPolicies.First().Key, "AAAA", null, "AAAA", null);
CloudTable sasTable = new CloudTable(table.Uri, new StorageCredentials(sasToken));
sasTable.Execute(TableOperation.Insert(new DynamicTableEntity("AAAA", "foo")));
TableResult result = sasTable.Execute(TableOperation.Retrieve("AAAA", "foo"));
Assert.IsNotNull(result.Result);
// revoke table permissions
table.SetPermissions(new TablePermissions());
Thread.Sleep(30 * 1000);
OperationContext opContext = new OperationContext();
try
{
sasTable.Execute(TableOperation.Insert(new DynamicTableEntity("AAAA", "foo2")), null, opContext);
Assert.Fail();
}
catch (Exception)
{
Assert.AreEqual(opContext.LastResult.HttpStatusCode, (int)HttpStatusCode.Forbidden);
}
opContext = new OperationContext();
try
{
result = sasTable.Execute(TableOperation.Retrieve("AAAA", "foo"), null, opContext);
Assert.Fail();
}
catch (Exception)
{
Assert.AreEqual(opContext.LastResult.HttpStatusCode, (int)HttpStatusCode.Forbidden);
}
}
finally
{
table.DeleteIfExists();
}
}
public void startingCode() {
Trace.TraceInformation("WorkerRole1 is running");
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.AppSettings["StorageConnectionString"]);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
table = tableClient.GetTableReference("urltable");
table.CreateIfNotExists();
infoTable = tableClient.GetTableReference("infotable");
infoTable.CreateIfNotExists();
errorTable = tableClient.GetTableReference("errortable");
errorTable.CreateIfNotExists();
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
queue = queueClient.GetQueueReference("urlstoqueue");
queue.CreateIfNotExists();
startStopQueue = queueClient.GetQueueReference("startstop");
startStopQueue.CreateIfNotExists();
state = "idle";
infoEntity newState = new infoEntity("state", state);
TableOperation insertInfoOperation = TableOperation.InsertOrReplace(newState);
infoTable.Execute(insertInfoOperation);
acceptedURLs = new HashSet<string>();
urlsCrawled = 0;
urlsAccepted = 0;
numErrors = 0;
queueSize = 0;
numTitles = 0;
lastTitle = "No titles crawled yet";
lastTen = new List<string>();
infoEntity newTotalNum = new infoEntity("total", urlsCrawled.ToString());
TableOperation insertTotalOperation = TableOperation.InsertOrReplace(newTotalNum);
infoTable.Execute(insertTotalOperation);
infoEntity newNumAccepted = new infoEntity("accepted", urlsAccepted.ToString());
TableOperation insertAcceptedOperation = TableOperation.InsertOrReplace(newNumAccepted);
infoTable.Execute(insertAcceptedOperation);
infoEntity newQueueSize = new infoEntity("queue", queueSize.ToString());
TableOperation insertNewQSize = TableOperation.InsertOrReplace(newQueueSize);
infoTable.Execute(insertNewQSize);
infoEntity num = new infoEntity("numTitles", numTitles.ToString());
TableOperation insertNum = TableOperation.InsertOrReplace(num);
infoTable.Execute(insertNum);
infoEntity last = new infoEntity("lastTitle", lastTitle);
TableOperation insertLast = TableOperation.InsertOrReplace(last);
infoTable.Execute(insertLast);
}
static void WritePlayer(CloudTable table, PlayerEntity player)
{
TableOperation insertOp = TableOperation.Insert(player);
table.Execute(insertOp);
}
private void UploadTableData(CloudTable table, XDocument document)
{
foreach (XElement xEntity in document.Root.Elements("entity"))
{
string partitionKey = xEntity.Element("PartitionKey").Value;
XElement xRowKey = xEntity.Element("RowKey");
string rowKey = xRowKey != null ? xRowKey.Value : "";
DynamicTableEntity tableEntity = new DynamicTableEntity(partitionKey, rowKey);
foreach (XElement xProperty in xEntity.Elements())
{
if (xProperty.Name != "PartitionKey" && xProperty.Name != "RowKey")
{
EntityProperty property = GetEntityProperty(xProperty);
tableEntity[xProperty.Name.LocalName] = property;
}
}
table.Execute(TableOperation.InsertOrReplace(tableEntity));
}
}
/// <summary>
/// Finds an existing account.
/// </summary>
/// <param name="accountTable">the account table.</param>
/// <param name="accountId">the account id.</param>
/// <returns>A matching entity or null.</returns>
private static AccountEntity FindExistingAccount(
CloudTable accountTable,
EmailAddress accountId)
{
TableOperation findExistingOperation = TableOperation.Retrieve<AccountEntity>(
accountId.Domain,
accountId.LocalPart);
TableResult findExistingResult = accountTable.Execute(findExistingOperation);
return findExistingResult.Result as AccountEntity;
}
