/// <summary> /// Validate the table access policy /// </summary> /// <param name="policy">SharedAccessBlobPolicy object</param> /// <param name="policyIdentifier">The policy identifier which need to be checked.</param> internal static bool ValidateTableAccessPolicy(IStorageTableManagement channel, string tableName, XTable.SharedAccessTablePolicy policy, string policyIdentifier) { if (string.IsNullOrEmpty(policyIdentifier)) { return(true); } XTable.CloudTable table = channel.GetTableReference(tableName); XTable.TableRequestOptions options = null; XTable.OperationContext context = null; XTable.TablePermissions permission = channel.GetTablePermissions(table, options, context); XTable.SharedAccessTablePolicy sharedAccessPolicy = GetExistingPolicy <XTable.SharedAccessTablePolicy>(permission.SharedAccessPolicies, policyIdentifier); if (policy.Permissions != XTable.SharedAccessTablePermissions.None) { throw new ArgumentException(Resources.SignedPermissionsMustBeOmitted); } if (policy.SharedAccessExpiryTime.HasValue && sharedAccessPolicy.SharedAccessExpiryTime.HasValue) { throw new ArgumentException(Resources.SignedExpiryTimeMustBeOmitted); } return(!sharedAccessPolicy.SharedAccessExpiryTime.HasValue); }
/// <summary> /// Get Storage Table Operation Context for rest calls /// </summary> /// <param name="outputWriter">Output writer for writing logs for each rest call</param> /// <returns>Storage Table operation context</returns> public static XTable.OperationContext GetStorageTableOperationContext(Action <string> outputWriter) { if (!_inited) { Init(); } var context = new XTable.OperationContext { ClientRequestID = ClientRequestId }; context.SendingRequest += (s, e) => { context.StartTime = DateTime.Now; Interlocked.Increment(ref _startedRemoteCallCounter); // TODO: Remove IfDef //https://github.com/Azure/azure-storage-net/issues/658 var message = String.Format(Resources.StartRemoteCall, _startedRemoteCallCounter, String.Empty, e.Request.RequestUri.ToString()); try { outputWriter?.Invoke(message); } catch { //catch the exception. If so, the storage client won't sleep and retry } }; context.ResponseReceived += (s, e) => { context.EndTime = DateTime.Now; Interlocked.Increment(ref _finishedRemoteCallCounter); var elapsedTime = (context.EndTime - context.StartTime).TotalMilliseconds; // TODO: Remove IfDef //https://github.com/Azure/azure-storage-net/issues/658 var message = String.Format(Resources.FinishRemoteCall, e.Request.RequestUri.ToString(), String.Empty, String.Empty, e.RequestInformation.ServiceRequestID, elapsedTime); try { outputWriter?.Invoke(message); } catch { //catch the exception. If so, the storage client won't sleep and retry } }; context.CustomUserAgent = ApiConstants.UserAgentHeaderValue; return(context); }
/// <summary> /// Delete the specified azure storage table /// </summary> /// <param name="table">Cloud table object</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> public void Delete(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { try { Task.Run(() => table.DeleteAsync(requestOptions, operationContext)).Wait(); } catch (AggregateException e) when(e.InnerException is XTable.StorageException) { throw e.InnerException; } }
public override IDictionary <string, EntityProperty> WriteEntity(Microsoft.Azure.Cosmos.Table.OperationContext operationContext) { var entityProperties = base.WriteEntity(operationContext); var objectProperties = this.GetType().GetProperties(); foreach (PropertyInfo property in objectProperties) { // see if the property has the attribute to not serialization, and if it does remove it from the entities to send to write object[] notSerializedAttributes = property.GetCustomAttributes(typeof(NotSerializedAttribute), false); if (notSerializedAttributes.Length > 0) { entityProperties.Remove(property.Name); } } return(entityProperties); }
/// <summary> /// List azure storage tables /// </summary> /// <param name="prefix">Table name prefix</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns>An enumerable collection of tables that begin with the specified prefix</returns> public IEnumerable <CloudTable> ListTables(string prefix, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { if (String.IsNullOrEmpty(prefix)) { return(tableList); } else { List <CloudTable> prefixTables = new List <CloudTable>(); foreach (CloudTable table in tableList) { if (table.Name.ToLower().StartsWith(prefix.ToLower())) { prefixTables.Add(table); } } return(prefixTables); } }
public void SetStorageTableServiceProperties(Azure.Cosmos.Table.ServiceProperties properties, XTable.TableRequestOptions options, XTable.OperationContext operationContext) { throw new NotImplementedException(); }
/// <summary> /// Return a task that asynchronously fetch table permissions /// </summary> /// <param name="table">target table</param> /// <param name="requestOptions">request options</param> /// <param name="operationContext">context</param> /// <returns></returns> public Task <TablePermissions> GetTablePermissionsAsync(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { return(Task.Factory.StartNew(() => this.GetTablePermissions(table, requestOptions, operationContext))); }
/// <summary> /// Set table permission /// </summary> /// <param name="table">Cloud table object</param> /// <param name="tablePermissions">table permissions</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns></returns> public void SetTablePermissions(CloudTable table, TablePermissions tablePermissions, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { this.tablePermissions = tablePermissions; }
public static IDictionary <string, EntityProperty> WriteUserObject(object entity, OperationContext operationContext) { CommonUtility.AssertNotNull("entity", entity); return(ReflectionWrite(entity, operationContext)); }
/// <summary> /// List azure storage tables /// </summary> /// <param name="prefix">Table name prefix</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns>An enumerable collection of tables that begin with the specified prefix</returns> public IEnumerable <CloudTable> ListTables(string prefix, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { //https://ahmet.im/blog/azure-listblobssegmentedasync-listcontainerssegmentedasync-how-to/ TableContinuationToken continuationToken = null; var results = new List <CloudTable>(); do { try { var response = tableClient.ListTablesSegmentedAsync(prefix, null, continuationToken, requestOptions, operationContext).Result; continuationToken = response.ContinuationToken; results.AddRange(response.Results); } catch (AggregateException e) when(e.InnerException is XTable.StorageException) { throw e.InnerException; } } while (continuationToken != null); return(results); }
public virtual void ReadEntity(IDictionary <string, EntityProperty> properties, OperationContext operationContext) { ReflectionRead(this, properties, operationContext); }
/// <summary> /// Set table permission /// </summary> /// <param name="table">Cloud table object</param> /// <param name="tablePermissions">table permissions</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns></returns> public void SetTablePermissions(CloudTable table, TablePermissions tablePermissions, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { try { Task.Run(() => table.SetPermissionsAsync(tablePermissions, requestOptions, operationContext)).Wait(); } catch (AggregateException e) when(e.InnerException is XTable.StorageException) { throw e.InnerException; } }
/// <summary> /// Checks whether the table exists. /// </summary> /// <param name="table">Cloud table object</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns>True if table exists; otherwise, false.</returns> public bool DoesTableExist(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { try { return(table.ExistsAsync(requestOptions, operationContext).Result); } catch (AggregateException e) when(e.InnerException is XTable.StorageException) { throw e.InnerException; } }
public static IDictionary <string, EntityProperty> Flatten(object entity, EntityPropertyConverterOptions entityPropertyConverterOptions, OperationContext operationContext) { CommonUtility.AssertNotNull("entity", entity); return(EntityPropertyConverter.Flatten(entity, entityPropertyConverterOptions, operationContext)); }
private static void ReflectionRead(object entity, IDictionary <string, EntityProperty> properties, OperationContext operationContext) { foreach (PropertyInfo item in (IEnumerable <PropertyInfo>)entity.GetType().GetProperties()) { if (!ShouldSkipProperty(item, operationContext)) { if (!properties.ContainsKey(item.Name)) { Logger.LogInformational(operationContext, "Omitting property '{0}' from de-serialization because there is no corresponding entry in the dictionary provided.", item.Name); } else { EntityProperty entityProperty = properties[item.Name]; if (entityProperty.IsNull) { item.SetValue(entity, null, null); } else { switch (entityProperty.PropertyType) { case EdmType.String: if (!(item.PropertyType != typeof(string))) { item.SetValue(entity, entityProperty.StringValue, null); } break; case EdmType.Binary: if (!(item.PropertyType != typeof(byte[]))) { item.SetValue(entity, entityProperty.BinaryValue, null); } break; case EdmType.Boolean: if (!(item.PropertyType != typeof(bool)) || !(item.PropertyType != typeof(bool?))) { item.SetValue(entity, entityProperty.BooleanValue, null); } break; case EdmType.DateTime: if (item.PropertyType == typeof(DateTime)) { item.SetValue(entity, entityProperty.DateTimeOffsetValue.Value.UtcDateTime, null); } else if (item.PropertyType == typeof(DateTime?)) { item.SetValue(entity, entityProperty.DateTimeOffsetValue.HasValue ? new DateTime?(entityProperty.DateTimeOffsetValue.Value.UtcDateTime) : null, null); } else if (item.PropertyType == typeof(DateTimeOffset)) { item.SetValue(entity, entityProperty.DateTimeOffsetValue.Value, null); } else if (item.PropertyType == typeof(DateTimeOffset?)) { item.SetValue(entity, entityProperty.DateTimeOffsetValue, null); } break; case EdmType.Double: if (!(item.PropertyType != typeof(double)) || !(item.PropertyType != typeof(double?))) { item.SetValue(entity, entityProperty.DoubleValue, null); } break; case EdmType.Guid: if (!(item.PropertyType != typeof(Guid)) || !(item.PropertyType != typeof(Guid?))) { item.SetValue(entity, entityProperty.GuidValue, null); } break; case EdmType.Int32: if (!(item.PropertyType != typeof(int)) || !(item.PropertyType != typeof(int?))) { item.SetValue(entity, entityProperty.Int32Value, null); } break; case EdmType.Int64: if (!(item.PropertyType != typeof(long)) || !(item.PropertyType != typeof(long?))) { item.SetValue(entity, entityProperty.Int64Value, null); } break; } } } } } }
public static TResult ConvertBack <TResult>(IDictionary <string, EntityProperty> properties, EntityPropertyConverterOptions entityPropertyConverterOptions, OperationContext operationContext) { return(EntityPropertyConverter.ConvertBack <TResult>(properties, entityPropertyConverterOptions, operationContext)); }
public static void ReadUserObject(object entity, IDictionary <string, EntityProperty> properties, OperationContext operationContext) { CommonUtility.AssertNotNull("entity", entity); ReflectionRead(entity, properties, operationContext); }
/// <summary> /// Get table reference from azure server /// </summary> /// <param name="name">Table name</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns>A CloudTable object if the specified table exists, otherwise null.</returns> public CloudTable GetTableReferenceFromServer(string name, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { foreach (CloudTable table in tableList) { if (table.Name == name) { return(table); } } return(null); }
/// <summary> /// Get the Table service properties /// </summary> /// <param name="account">Cloud storage account</param> /// <param name="options">Request options</param> /// <param name="operationContext">Operation context</param> /// <returns>The service properties of the specified service type</returns> public XTable.ServiceProperties GetStorageTableServiceProperties(XTable.TableRequestOptions options, XTable.OperationContext operationContext) { XTable.CloudStorageAccount account = StorageContext.TableStorageAccount; try { return(account.CreateCloudTableClient().GetServicePropertiesAsync(options, operationContext).Result); } catch (AggregateException e) when(e.InnerException is XTable.StorageException) { throw e.InnerException; } }
/// <summary> /// Return a task that asynchronously fetch table permissions /// </summary> /// <param name="table">target table</param> /// <param name="requestOptions">request options</param> /// <param name="operationContext">context</param> /// <returns></returns> public Task <TablePermissions> GetTablePermissionsAsync(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { return(Task.FromResult(this.GetTablePermissions(table, requestOptions, operationContext))); }
private static IDictionary <string, EntityProperty> ReflectionWrite(object entity, OperationContext operationContext) { Dictionary <string, EntityProperty> dictionary = new Dictionary <string, EntityProperty>(); foreach (PropertyInfo item in (IEnumerable <PropertyInfo>)entity.GetType().GetProperties()) { if (!ShouldSkipProperty(item, operationContext)) { EntityProperty entityProperty = EntityProperty.CreateEntityPropertyFromObject(item.GetValue(entity, null), item.PropertyType); if (entityProperty != null) { dictionary.Add(item.Name, entityProperty); } } } return(dictionary); }
/// <summary> /// Get table permission /// </summary> /// <param name="table">Cloud table object</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> public TablePermissions GetTablePermissions(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { try { return(table.GetPermissionsAsync(requestOptions, operationContext).Result); } catch (AggregateException e) when(e.InnerException is XTable.StorageException) { throw e.InnerException; } }
/// <summary> /// Cloud a azure storage table if not exists. /// </summary> /// <param name="table">Cloud table object</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns>True if table was created; otherwise, false.</returns> public bool CreateTableIfNotExists(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { CloudTable tableRef = GetTableReferenceFromServer(table.Name, requestOptions, operationContext); if (tableRef != null) { return(false); } else { tableRef = GetTableReference(table.Name); tableList.Add(tableRef); return(true); } }
/// <summary> /// Return a task that asynchronously set table permissions /// </summary> /// <param name="table">target table</param> /// <param name="tablePermissions">permissions to set</param> /// <param name="requestOptions">request options</param> /// <param name="operationContext">context</param> /// <returns></returns> public Task SetTablePermissionsAsync(CloudTable table, TablePermissions tablePermissions, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { return(table.SetPermissionsAsync(tablePermissions, requestOptions, operationContext)); }
/// <summary> /// Delete the specified azure storage table /// </summary> /// <param name="table">Cloud table object</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> public void Delete(CloudTable table, TableRequestOptions requestOptions = null, XTable.OperationContext operationContext = null) { foreach (CloudTable tableRef in tableList) { if (table.Name == tableRef.Name) { tableList.Remove(tableRef); return; } } }
/// <summary> /// Set Table service properties /// </summary> /// <param name="account">Cloud storage account</param> /// <param name="properties">Service properties</param> /// <param name="options">Request options</param> /// <param name="operationContext">Operation context</param> public void SetStorageTableServiceProperties(XTable.ServiceProperties properties, XTable.TableRequestOptions options, XTable.OperationContext operationContext) { XTable.CloudStorageAccount account = StorageContext.TableStorageAccount; try { Task.Run(() => account.CreateCloudTableClient().SetServicePropertiesAsync(properties, options, operationContext)).Wait(); } catch (AggregateException e) when(e.InnerException is XTable.StorageException) { throw e.InnerException; } }
/// <summary> /// Checks whether the table exists. /// </summary> /// <param name="table">Cloud table object</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns>True if table exists; otherwise, false.</returns> public bool DoesTableExist(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { foreach (CloudTable tableRef in tableList) { if (table.Name == tableRef.Name) { return(true); } } return(false); }
/// <summary> /// Get table permission /// </summary> /// <param name="table">CloudTable object</param> /// <param name="requestOptions">Table request options</param> /// <param name="operationContext">Operation context</param> /// <returns>Table permission</returns> public TablePermissions GetTablePermissions(CloudTable table, TableRequestOptions requestOptions, XTable.OperationContext operationContext) { return(this.tablePermissions); }
public virtual IDictionary <string, EntityProperty> WriteEntity(OperationContext operationContext) { return(ReflectionWrite(this, operationContext)); }