Пример #1
0
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "post")] ApplicationInfo info,
            ILogger log)
        {
            var table = TableUtilities.GetCloudTable("Applications");

            var operation = TableOperation.Retrieve <ApplicationEntity>(info.GroupId, info.ApplicationId);
            var result    = await table.ExecuteAsync(operation);

            var application = result.Result as ApplicationEntity;

            if (application == null)
            {
                return(new NotFoundResult());
            }

            if (application.Password.Equals(info.Password) == false)
            {
                return(new UnauthorizedResult());
            }

            operation = TableOperation.Delete(application);
            await table.ExecuteAsync(operation);

            return(new NoContentResult());
        }
        /// <summary>
        /// Callback on DataContext object sending request.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="System.Data.Services.Client.SendingRequestEventArgs"/> instance containing the event data.</param>
        private void TableServiceContext_SendingRequest(object sender, SendingRequestEventArgs e)
        {
            HttpWebRequest request = e.Request as HttpWebRequest;

            // Check timeout
            int timeoutDex = request.RequestUri.Query.LastIndexOf("&timeout=", System.StringComparison.Ordinal);

            if (timeoutDex > 0)
            {
                timeoutDex += 9; // Magic number -> length of "&timeout="
                int    endDex        = request.RequestUri.Query.IndexOf('&', timeoutDex);
                string timeoutString = endDex > 0
                                           ? request.RequestUri.Query.Substring(timeoutDex, endDex - timeoutDex)
                                           : request.RequestUri.Query.Substring(timeoutDex);

                int result = -1;
                if (int.TryParse(timeoutString, out result) && result > 0)
                {
                    request.Timeout = result * 1000; // Convert to ms
                }
            }

            // Sign request
            if (this.ServiceClient.Credentials.IsSharedKey)
            {
                this.AuthenticationHandler.SignRequest(request, null /* operationContext */);
            }
            else if (this.ServiceClient.Credentials.IsSAS)
            {
                Uri transformedUri = this.ServiceClient.Credentials.TransformUri(request.RequestUri);

                // Recreate the request
                HttpWebRequest newRequest = WebRequest.Create(transformedUri) as HttpWebRequest;
                TableUtilities.CopyRequestData(newRequest, request);
                e.Request = newRequest;
                request   = newRequest;
            }

            lock (this.cancellationLock)
            {
                if (this.cancellationRequested)
                {
                    throw new OperationCanceledException(SR.OperationCanceled);
                }

                this.currentRequest = request;
            }

            // SAS will be handled directly by the queries themselves prior to transformation
            request.Headers.Add(
                Constants.HeaderConstants.StorageVersionHeader,
                Constants.HeaderConstants.TargetStorageVersion);

            CommonUtility.ApplyRequestOptimizations(request, -1);

            if (this.sendingSignedRequestAction != null)
            {
                this.sendingSignedRequestAction(request);
            }
        }
 public static void TestingTables1()
 {
     TableUtilities tableUtil = new TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
     List<string> tables;
     Console.WriteLine("List tables ");
     if (tableUtil.ListTables(out tables))
     {
         Console.WriteLine("true");
         if (tables != null)
         {
             foreach (string tableName in tables)
             {
                 Console.Write(tableName + " ");
             }
             Console.WriteLine();
         }
     }
     else
         Console.WriteLine("false");
     Separator();
     Console.WriteLine("Create table ");
     if (tableUtil.CreateTable("sampletable"))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
     Separator();
 }
Пример #4
0
        private ResultSegment <TElement> ParseTableQueryResponse(IEnumerable <TElement> dataServiceQueryResponse, RequestResult reqResult, TableCommand <ResultSegment <TElement>, IEnumerable <TElement> > cmd)
        {
            if (reqResult.Exception != null)
            {
                DataServiceClientException dsce = TableUtilities.FindInnerExceptionOfType <DataServiceClientException>(reqResult.Exception);

                if (this.IgnoreResourceNotFoundException && dsce != null && (HttpStatusCode)dsce.StatusCode == HttpStatusCode.NotFound)
                {
                    return(new ResultSegment <TElement>(new List <TElement>()));
                }

                throw reqResult.Exception;
            }

            QueryOperationResponse response = dataServiceQueryResponse as QueryOperationResponse;

            ResultSegment <TElement> retSeg = new ResultSegment <TElement>(dataServiceQueryResponse.ToList());

            // Get continuation token from response
            retSeg.ContinuationToken = TableUtilities.ContinuationFromResponse(response);
            if (retSeg.ContinuationToken != null)
            {
                retSeg.ContinuationToken.TargetLocation = reqResult.TargetLocation;
            }

            return(retSeg);
        }
Пример #5
0
        private static SortedSet <string> GetCacheDependencies(
            DbCommand command,
            DbContext context,
            CachePolicy cachePolicy)
        {
            if (command is null)
            {
                throw new ArgumentNullException(nameof(command));
            }

            if (cachePolicy is null)
            {
                throw new ArgumentNullException(nameof(cachePolicy));
            }

            var tableNames = new SortedSet <string>(
                TableUtilities.GetTableNamesByContext(context).Select(x => x.TableName),
                StringComparer.OrdinalIgnoreCase);
            var textsInsideSquareBrackets = TableUtilities.GetSqlCommandTableNames(command.CommandText);
            var cacheDependencies         = new SortedSet <string>(
                tableNames.Intersect(textsInsideSquareBrackets, StringComparer.OrdinalIgnoreCase),
                StringComparer.OrdinalIgnoreCase);

            if (cacheDependencies.Any())
            {
                return(cacheDependencies);
            }

            return(new SortedSet <string>());
        }
        public IEnumerable <TElement> Execute(TableRequestOptions requestOptions = null, OperationContext operationContext = null)
        {
            requestOptions   = TableRequestOptions.ApplyDefaults(requestOptions, this.Context.ServiceClient);
            operationContext = operationContext ?? new OperationContext();
            long takeCount = TableUtilities.GetQueryTakeCount(this.Query, long.MaxValue);

            return(CommonUtility.LazyEnumerable(
                       (continuationToken) => this.ExecuteSegmentedCore((TableContinuationToken)continuationToken, requestOptions, operationContext),
                       takeCount));
        }
Пример #7
0
        /// <summary>
        /// Tries to translate the specified exception into a storage exception.
        /// </summary>
        /// <param name="ex">The exception to translate.</param>
        /// <param name="reqResult">The request result.</param>
        /// <param name="parseError">The delegate used to parse the error to get extended error information.</param>
        /// <returns>The storage exception or <c>null</c>.</returns>
        private static StorageException CoreTranslate(Exception ex, RequestResult reqResult, ref Func <Stream, StorageExtendedErrorInformation> parseError)
        {
            CommonUtility.AssertNotNull("reqResult", reqResult);
            CommonUtility.AssertNotNull("ex", ex);

            if (parseError == null)
            {
                parseError = StorageExtendedErrorInformation.ReadFromStream;
            }

            // Dont re-wrap storage exceptions
            if (ex is StorageException)
            {
                return((StorageException)ex);
            }
            else if (ex is TimeoutException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = (int)HttpStatusCode.RequestTimeout;
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex));
            }
            else if (ex is ArgumentException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = (int)HttpStatusCode.Unused;
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex)
                {
                    IsRetryable = false
                });
            }
#if WINDOWS_RT
            else if (ex is OperationCanceledException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = 306; // unused
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex));
            }
#elif WINDOWS_DESKTOP && !WINDOWS_PHONE
            else
            {
                // Should never get to this one since we will call TranslateDataServiceException for DataService operations.
                StorageException tableEx = TableUtilities.TranslateDataServiceException(ex, reqResult, null);

                if (tableEx != null)
                {
                    return(tableEx);
                }
            }
#endif
            // return null and check in the caller
            return(null);
        }
Пример #8
0
        /// <summary>
        /// Translates the specified exception into a storage exception.
        /// </summary>
        /// <param name="ex">The exception to translate.</param>
        /// <param name="reqResult">The request result.</param>
        /// <param name="parseError">The delegate used to parse the error to get extended error information.</param>
        /// <returns>The storage exception.</returns>
        internal static StorageException TranslateDataServiceException(Exception ex, RequestResult reqResult, Func <Stream, IDictionary <string, string>, StorageExtendedErrorInformation> parseError)
        {
            CommonUtility.AssertNotNull("reqResult", reqResult);
            CommonUtility.AssertNotNull("ex", ex);
            CommonUtility.AssertNotNull("parseError", parseError);

            // Dont re-wrap storage exceptions
            if (ex is StorageException)
            {
                return((StorageException)ex);
            }
            else if (ex is TimeoutException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = (int)HttpStatusCode.RequestTimeout;
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex));
            }
            else if (ex is ArgumentException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = (int)HttpStatusCode.Unused;
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex)
                {
                    IsRetryable = false
                });
            }
            else
            {
                StorageException tableEx = TableUtilities.TranslateDataServiceException(ex, reqResult, parseError);

                if (tableEx != null)
                {
                    return(tableEx);
                }
            }

            // Just wrap in StorageException
            return(new StorageException(reqResult, ex.Message, ex));
        }
 public static void TestingTables2() // TestingQueues2
 {
     TableUtilities tableUtil = new
         TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
     Console.WriteLine("Insert entity ");
     if (tableUtil.InsertEntity("sampletable",
         new Contact("USA", "Pallmann") { LastName = "Pallmann", FirstName = "David",
             Email = "*****@*****.**", Country = "USA" }))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
     
     Separator();
     Console.WriteLine("Insert entity ");
     if (tableUtil.InsertEntity("sampletable",
         new Contact("USA", "Smith") { LastName = "Smith", FirstName = "John", Email =
             "*****@*****.**", Country = "USA" }))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
     
     Separator();
     Console.Write("Insert entity ");
     if (tableUtil.InsertEntity("sampletable",
         new Contact("USA", "Jones") { LastName = "Jones", FirstName = "Tom", Email =
             "*****@*****.**", Country = "USA" }))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
     
     Separator();
     Console.Write("Insert entity ");
     if (tableUtil.InsertEntity("sampletable",
         new Contact("USA", "Peters") { LastName = "Peters", FirstName = "Sally", Email =
             "*****@*****.**", Country = "USA" }))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
     Separator();
 }
        private TableCommand <ResultSegment <TElement>, IEnumerable <TElement> > GenerateExecuteCommand(TableContinuationToken continuationToken, TableRequestOptions requestOptions)
        {
            DataServiceQuery <TElement> localQuery = this.Query;

            // Continuation
            localQuery = TableUtilities.ApplyContinuationToQuery <TElement>(continuationToken, localQuery);

            if (requestOptions.ServerTimeout.HasValue)
            {
                localQuery = localQuery.AddQueryOption("timeout", Convert.ToString(requestOptions.ServerTimeout.Value.TotalSeconds));
            }

            TableCommand <ResultSegment <TElement>, IEnumerable <TElement> > cmd = new TableCommand <ResultSegment <TElement>, IEnumerable <TElement> >();

            cmd.ExecuteFunc   = localQuery.Execute;
            cmd.Begin         = (callback, state) => localQuery.BeginExecute(callback, state);
            cmd.End           = localQuery.EndExecute;
            cmd.ParseResponse = this.ParseTableQueryResponse;
            cmd.ApplyRequestOptions(requestOptions);
            cmd.Context = this.Context;
            return(cmd);
        }
Пример #11
0
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "post")] ApplicationInfo info,
            ILogger log)
        {
            var table = TableUtilities.GetCloudTable("Applications");

            var operation = TableOperation.Retrieve <ApplicationEntity>(info.GroupId, info.ApplicationId);
            var result    = await table.ExecuteAsync(operation);

            var application = result.Result as ApplicationEntity;

            if (application != null)
            {
                return(new ConflictResult());
            }

            var query = table.CreateQuery <ApplicationEntity>()
                        .Where(p => p.PartitionKey.Equals(info.GroupId))
                        .AsTableQuery();

            var entities = await table.ExecuteQueryAsync(query);

            if (entities.Count > 0 && entities.First().Password.Equals(info.Password) == false)
            {
                return(new UnauthorizedResult());
            }


            operation = TableOperation.Insert(new ApplicationEntity
            {
                PartitionKey = info.GroupId,
                RowKey       = info.ApplicationId,
                MachineName  = info.MachineName,
                Password     = info.Password
            });
            await table.ExecuteAsync(operation);

            return(new NoContentResult());
        }
Пример #12
0
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] ChangePasswordInfo info,
            ILogger log)
        {
            var table = TableUtilities.GetCloudTable("Applications");

            var operation = TableOperation.Retrieve <ApplicationEntity>(info.GroupId, info.ApplicationId);
            var result    = await table.ExecuteAsync(operation);

            var application = result.Result as ApplicationEntity;

            if (application == null)
            {
                return(new NotFoundResult());
            }

            if (application.Password.Equals(info.Password) == false)
            {
                return(new UnauthorizedResult());
            }

            var query = table.CreateQuery <ApplicationEntity>()
                        .Where(p => p.PartitionKey.Equals(info.GroupId))
                        .AsTableQuery();

            var entities = await table.ExecuteQueryAsync(query);

            var batch = new TableBatchOperation();

            foreach (var entity in entities)
            {
                entity.Password = info.NewPassword;
                batch.Replace(entity);
            }
            await table.ExecuteBatchAsync(batch);

            return(new NoContentResult());
        }
Пример #13
0
        /// <summary>
        /// Translates the specified exception into a storage exception.
        /// </summary>
        /// <param name="ex">The exception to translate.</param>
        /// <param name="reqResult">The request result.</param>
        /// <returns>The storage exception.</returns>
        public static StorageException TranslateException(Exception ex, RequestResult reqResult)
        {
            // Dont re-wrap storage exceptions
            if (ex is StorageException)
            {
                return((StorageException)ex);
            }
            else if (ex is TimeoutException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = (int)HttpStatusCode.Unused;
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex));
            }
            else if (ex is ArgumentException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = (int)HttpStatusCode.Unused;
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex)
                {
                    IsRetryable = false
                });
            }
#if RT || XAMARIN
            else if (ex is OperationCanceledException)
            {
                reqResult.HttpStatusMessage        = null;
                reqResult.HttpStatusCode           = 306; // unused
                reqResult.ExtendedErrorInformation = null;
                return(new StorageException(reqResult, ex.Message, ex));
            }
#elif DNCP
            else
            {
                StorageException tableEx = TableUtilities.TranslateDataServiceClientException(ex, reqResult);

                if (tableEx != null)
                {
                    return(tableEx);
                }
            }
#endif

            WebException we = ex as WebException;
            if (we != null)
            {
                try
                {
                    HttpWebResponse response = we.Response as HttpWebResponse;
                    if (response != null)
                    {
                        reqResult.HttpStatusMessage = response.StatusDescription;
                        reqResult.HttpStatusCode    = (int)response.StatusCode;
                        if (response.Headers != null)
                        {
#if DNCP
                            reqResult.ServiceRequestID = HttpUtility.TryGetHeader(response, Constants.HeaderConstants.RequestIdHeader, null);
                            reqResult.ContentMd5       = HttpUtility.TryGetHeader(response, "Content-MD5", null);
                            string tempDate = HttpUtility.TryGetHeader(response, "Date", null);
                            reqResult.RequestDate = string.IsNullOrEmpty(tempDate) ? DateTime.Now.ToString("R", CultureInfo.InvariantCulture) : tempDate;
                            reqResult.Etag        = response.Headers[HttpResponseHeader.ETag];
#endif
                        }
#if RT
                        reqResult.ExtendedErrorInformation = StorageExtendedErrorInformation.ReadFromStream(response.GetResponseStream().AsInputStream());
#else
                        reqResult.ExtendedErrorInformation = StorageExtendedErrorInformation.ReadFromStream(response.GetResponseStream());
#endif
                    }
                }
                catch (Exception)
                {
                    // no op
                }
            }

            // Not WebException, just wrap in StorageException
            return(new StorageException(reqResult, ex.Message, ex));
        }
 public static void TestingTables4()
 {
     TableUtilities tableUtil = new
     TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
     Console.Write("Merge Update entity. Preserves the unchanged properties. ");
     if (tableUtil.MergeUpdateEntity("sampletable", "USA", "Peters",
     new MiniContact("USA", "Peters")
     {
         LastName = "Peters",
         FirstName = "Sally",
         Email =
             "*****@*****.**"
     }))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
 }
 public static void TestingTables5()
 {
     TableUtilities tableUtil = new
     TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
     Contact contact = null;
     Separator();
     Console.Write("Get entity ");
     if (tableUtil.GetEntity<Contact>("sampletable", "USA", "Pallmann", out contact))
     {
         Console.WriteLine("true");
         if (contact != null)
         {
             Console.WriteLine("Contact.LastName: " + contact.LastName);
             Console.WriteLine("Contact.FirstName: " + contact.FirstName);
             Console.WriteLine("Contact.Email: " + contact.Email);
             Console.WriteLine("Contact.Phone: " + contact.Phone);
             Console.WriteLine("Contact.Country: " + contact.Country);
         }
         else
             Console.WriteLine("Contact <NULL>");
     }
     else
         Console.WriteLine("false");
     Separator();
     //Contact
         contact = null;
     Console.Write("Get entity ");
     if (tableUtil.GetEntity<Contact>("sampletable", "USA", "Smith", out contact))
     {
         Console.WriteLine("true");
         if (contact != null)
         {
             Console.WriteLine("Contact.LastName: " + contact.LastName);
             Console.WriteLine("Contact.FirstName: " + contact.FirstName);
             Console.WriteLine("Contact.Email: " + contact.Email);
             Console.WriteLine("Contact.Phone: " + contact.Phone);
             Console.WriteLine("Contact.Country: " + contact.Country);
         }
         else
             Console.WriteLine("Contact <NULL>");
     }
     else
     {
         Console.WriteLine("false");
     }
     Separator();
 }
 public static void TestingTables6()
 {
     TableUtilities tableUtil = new
     TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
     Console.Write("Query entities ");
     IEnumerable<Contact> entities = tableUtil.QueryEntities<Contact>("sampletable").Where(e =>
     e.PartitionKey == "USA").AsTableServiceQuery<Contact>();
     if (entities != null)
     {
         Console.WriteLine("true");
         foreach (Contact contact1 in entities)
         {
             Console.WriteLine("Contact.LastName: " + contact1.LastName);
             Console.WriteLine("Contact.FirstName: " + contact1.FirstName);
             Console.WriteLine("Contact.Email: " + contact1.Email);
             Console.WriteLine("Contact.Phone: " + contact1.Phone);
             Console.WriteLine("Contact.Country: " + contact1.Country);
             Console.WriteLine();
         }
     }
     else
         Console.WriteLine("<NULL>");
 }
 public static void TestingTables3()
 {
     TableUtilities tableUtil = new TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
     Console.Write("Update entity ");
     if (tableUtil.ReplaceUpdateEntity("sampletable", "USA", "Pallmann",
     new Contact("USA", "Pallmann")
     {
         LastName = "Pallmann",
         FirstName = "David",
         Email =
             "*****@*****.**",
         Country = "USA"
     }))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
     Separator();
     Console.Write("Replace Update entity ");
     if (tableUtil.ReplaceUpdateEntity("sampletable", "USA", "Peters",
     new Contact("USA", "Peters")
     {
         LastName = "Peters",
         FirstName = "Sally",
         Country = "USA"
     }))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
     Separator();
 }
 public static void TestingTables7()
 {
     TableUtilities tableUtil = new
     TableUtilities("DefaultEndpointsProtocol=http;AccountName=" + ACCOUNTNAME + ";AccountKey=" + ACCOUNTKEY + "");
     Separator();
     Console.Write("Delete entity ");
     if (tableUtil.DeleteEntity<Contact>("sampletable", "USA", "Smith"))
         Console.WriteLine("true");
     else
         Console.WriteLine("false");
 }