public async Task BlobServiceCors()
        {
            BlobServiceData properties1 = _blobService.Data;
            BlobServiceData properties2 = new BlobServiceData();

            properties2.DeleteRetentionPolicy         = new DeleteRetentionPolicy();
            properties2.DeleteRetentionPolicy.Enabled = true;
            properties2.DeleteRetentionPolicy.Days    = 300;
            properties2.DefaultServiceVersion         = "2017-04-17";
            properties2.Cors = new CorsRules();
            properties2.Cors.CorsRulesValue.Add(new CorsRule(new string[] { "http://www.contoso.com", "http://www.fabrikam.com" },
                                                             new CorsRuleAllowedMethodsItem[] { CorsRuleAllowedMethodsItem.GET, CorsRuleAllowedMethodsItem.PUT },
                                                             100, new string[] { "x-ms-meta-*" },
                                                             new string[] { "x-ms-meta-abc", "x-ms-meta-data*", "x-ms-meta-target*" }
                                                             ));
            properties2.Cors.CorsRulesValue.Add(new CorsRule(new string[] { "*" },
                                                             new CorsRuleAllowedMethodsItem[] { CorsRuleAllowedMethodsItem.GET },
                                                             2, new string[] { "*" },
                                                             new string[] { "*" }
                                                             ));
            properties2.Cors.CorsRulesValue.Add(new CorsRule(new string[] { "http://www.abc23.com", "https://www.fabrikam.com/*" },
                                                             new CorsRuleAllowedMethodsItem[] { CorsRuleAllowedMethodsItem.GET, CorsRuleAllowedMethodsItem.PUT, CorsRuleAllowedMethodsItem.Post },
                                                             2000, new string[] { "x-ms-meta-12345675754564*" },
                                                             new string[] { "x-ms-meta-abc", "x-ms-meta-data*", "x-ms-meta-target*" }
                                                             ));

            _blobService = (await _blobService.CreateOrUpdateAsync(properties2)).Value;
            BlobServiceData properties3 = _blobService.Data;

            Assert.IsTrue(properties3.DeleteRetentionPolicy.Enabled);
            Assert.AreEqual(300, properties3.DeleteRetentionPolicy.Days);
            Assert.AreEqual("2017-04-17", properties3.DefaultServiceVersion);

            //validate CORS rules
            Assert.AreEqual(properties2.Cors.CorsRulesValue.Count, properties3.Cors.CorsRulesValue.Count);
            for (int i = 0; i < properties2.Cors.CorsRulesValue.Count; i++)
            {
                CorsRule putRule = properties2.Cors.CorsRulesValue[i];
                CorsRule getRule = properties3.Cors.CorsRulesValue[i];

                Assert.AreEqual(putRule.AllowedHeaders, getRule.AllowedHeaders);
                Assert.AreEqual(putRule.AllowedMethods, getRule.AllowedMethods);
                Assert.AreEqual(putRule.AllowedOrigins, getRule.AllowedOrigins);
                Assert.AreEqual(putRule.ExposedHeaders, getRule.ExposedHeaders);
                Assert.AreEqual(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
            }

            _blobService = await _blobService.GetAsync();

            BlobServiceData properties4 = _blobService.Data;

            Assert.IsTrue(properties4.DeleteRetentionPolicy.Enabled);
            Assert.AreEqual(300, properties4.DeleteRetentionPolicy.Days);
            Assert.AreEqual("2017-04-17", properties4.DefaultServiceVersion);

            //validate CORS rules
            Assert.AreEqual(properties2.Cors.CorsRulesValue.Count, properties4.Cors.CorsRulesValue.Count);
            for (int i = 0; i < properties2.Cors.CorsRulesValue.Count; i++)
            {
                CorsRule putRule = properties2.Cors.CorsRulesValue[i];
                CorsRule getRule = properties4.Cors.CorsRulesValue[i];

                Assert.AreEqual(putRule.AllowedHeaders, getRule.AllowedHeaders);
                Assert.AreEqual(putRule.AllowedMethods, getRule.AllowedMethods);
                Assert.AreEqual(putRule.AllowedOrigins, getRule.AllowedOrigins);
                Assert.AreEqual(putRule.ExposedHeaders, getRule.ExposedHeaders);
                Assert.AreEqual(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
            }
        }
Ejemplo n.º 2
0
        public void CloudTableTestValidCorsRules()
        {
            CorsRule ruleMinRequired = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.xyz.com"
                },
                AllowedMethods = CorsHttpMethods.Get
            };

            CorsRule ruleBasic = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.ab.com", "www.bc.com"
                },
                AllowedMethods  = CorsHttpMethods.Get | CorsHttpMethods.Put,
                MaxAgeInSeconds = 500,
                ExposedHeaders  =
                    new List <string>()
                {
                    "x-ms-meta-data*",
                    "x-ms-meta-source*",
                    "x-ms-meta-abc",
                    "x-ms-meta-bcd"
                },
                AllowedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-data*",
                    "x-ms-meta-target*",
                    "x-ms-meta-xyz",
                    "x-ms-meta-foo"
                }
            };

            CorsRule ruleAllMethods = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.xyz.com"
                },
                AllowedMethods =
                    CorsHttpMethods.Put | CorsHttpMethods.Trace
                    | CorsHttpMethods.Connect | CorsHttpMethods.Delete
                    | CorsHttpMethods.Get | CorsHttpMethods.Head
                    | CorsHttpMethods.Options | CorsHttpMethods.Post
                    | CorsHttpMethods.Merge
            };

            CorsRule ruleSingleExposedHeader = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                ExposedHeaders = new List <string>()
                {
                    "x-ms-meta-bcd"
                },
            };

            CorsRule ruleSingleExposedPrefixHeader = new CorsRule()
            {
                AllowedOrigins =
                    new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                ExposedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-data*"
                },
            };

            CorsRule ruleSingleAllowedHeader = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders = new List <string>()
                {
                    "x-ms-meta-xyz",
                },
            };

            CorsRule ruleSingleAllowedPrefixHeader = new CorsRule()
            {
                AllowedOrigins =
                    new List <string>()
                {
                    "www.ab.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-target*"
                },
            };

            CorsRule ruleAllowAll = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "*"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders = new List <string>()
                {
                    "*"
                },
                ExposedHeaders = new List <string>()
                {
                    "*"
                }
            };

            CloudTableClient client = GenerateCloudTableClient();

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleBasic
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleMinRequired
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleAllMethods
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleExposedHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleExposedPrefixHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleAllowedHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleSingleAllowedPrefixHeader
            });

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleAllowAll
            });

            // Empty rule set should delete all rules
            this.TestCorsRules(client, new List <CorsRule>()
            {
            });

            // Test duplicate rules
            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleBasic, ruleBasic
            });

            // Test max number of  rules (five)
            this.TestCorsRules(
                client,
                new List <CorsRule>()
            {
                ruleBasic,
                ruleMinRequired,
                ruleAllMethods,
                ruleSingleExposedHeader,
                ruleSingleExposedPrefixHeader
            });


            // Test max number of rules + 1 (six)
            TestHelper.ExpectedException(
                () =>
                this.TestCorsRules(
                    client,
                    new List <CorsRule>()
            {
                ruleBasic,
                ruleMinRequired,
                ruleAllMethods,
                ruleSingleExposedHeader,
                ruleSingleExposedPrefixHeader,
                ruleSingleAllowedHeader
            }),
                "Services are limited to a maximum of five CORS rules.",
                HttpStatusCode.BadRequest,
                "InvalidXmlDocument");
        }
Ejemplo n.º 3
0
 private static CorsRule Clone(CorsRule rule)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 4
0
        public string EnableStorageCORS(Account account)
        {
            try
            {
                var storageAccount = StorageUtils.CreateCloudStorageAccount(account);
                var blobClient     = storageAccount.CreateCloudBlobClient();

                CorsHttpMethods allowedMethods = CorsHttpMethods.None;
                allowedMethods = allowedMethods | CorsHttpMethods.Get;
                allowedMethods = allowedMethods | CorsHttpMethods.Put;
                allowedMethods = allowedMethods | CorsHttpMethods.Post;
                allowedMethods = allowedMethods | CorsHttpMethods.Delete;
                allowedMethods = allowedMethods | CorsHttpMethods.Options;

                var          delimiter      = new[] { "," };
                CorsRule     corsRule       = new CorsRule();
                const string allowedOrigins = "*";
                const string allowedHeaders = "*";
                const string exposedHeaders = "";

                string[] allAllowedOrigin = allowedOrigins.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
                string[] allExpHeaders    = exposedHeaders.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
                string[] allAllowHeaders  = allowedHeaders.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);

                List <string> corsAllowedOrigin = new List <string>();
                foreach (var item in allAllowedOrigin)
                {
                    if (!string.IsNullOrWhiteSpace(item))
                    {
                        corsAllowedOrigin.Add(item.Trim());
                    }
                }
                List <string> corsExposedHeaders = new List <string>();
                foreach (var item in allExpHeaders)
                {
                    if (!string.IsNullOrWhiteSpace(item))
                    {
                        corsExposedHeaders.Add(item.Trim());
                    }
                }
                List <string> corsAllowHeaders = new List <string>();
                foreach (var item in allAllowHeaders)
                {
                    if (!string.IsNullOrWhiteSpace(item))
                    {
                        corsAllowHeaders.Add(item.Trim());
                    }
                }
                corsRule.MaxAgeInSeconds = 200;
                corsRule.AllowedMethods  = allowedMethods;
                corsRule.AllowedHeaders  = corsAllowHeaders;
                corsRule.AllowedOrigins  = corsAllowedOrigin;
                corsRule.ExposedHeaders  = corsExposedHeaders;
                ServiceProperties properties = blobClient.GetServiceProperties();
                properties.Cors.CorsRules.Clear();
                properties.Cors.CorsRules.Add(corsRule);
                blobClient.SetServiceProperties(properties);
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                return("Failed due to Incorrect Account Name or Key.");
            }
            return("Enabling CORS Succeed");
        }
Ejemplo n.º 5
0
        public async Task FileServiceCorsTest()
        {
            // Create resource group
            var rgName = await CreateResourceGroupAsync();

            string accountName = Recording.GenerateAssetName("sto");

            // Create storage account
            StorageAccount account = await CreateStorageAccountAsync(rgName, accountName);

            VerifyAccountProperties(account, true);

            // implement case
            Response <FileServiceProperties> properties1 = await FileServicesClient.GetServicePropertiesAsync(rgName, accountName);

            Assert.AreEqual(0, properties1.Value.Cors.CorsRulesValue.Count());

            properties1.Value.Cors = new CorsRules
            {
                CorsRulesValue =
                {
                    new CorsRule(allowedOrigins: new string[]                     { "http://www.contoso.com", "http://www.fabrikam.com"    },
                                 allowedMethods: new CorsRuleAllowedMethodsItem[] { "GET",                    "HEAD", "POST", "OPTIONS", "MERGE", "PUT"},
                                 maxAgeInSeconds: 100,
                                 exposedHeaders: new string[]                     { "x-ms-meta-*" },
                                 allowedHeaders: new string[]                     { "x-ms-meta-abc",          "x-ms-meta-data*", "x-ms-meta-target*"}),

                    new CorsRule(allowedOrigins: new string[]                     { "*" },
                                 allowedMethods: new CorsRuleAllowedMethodsItem[] { "GET" },
                                 maxAgeInSeconds: 2,
                                 exposedHeaders: new string[]                     { "*" },
                                 allowedHeaders: new string[]                     { "*" }),

                    new CorsRule(allowedOrigins: new string[]                     { "http://www.abc23.com",   "https://www.fabrikam.com/*" },
                                 allowedMethods: new CorsRuleAllowedMethodsItem[] { "GET",                    "PUT", "CONNECT"             },
                                 maxAgeInSeconds: 2000,
                                 exposedHeaders: new string[]                     { "x-ms-meta-abc",          "x-ms-meta-data*", "x -ms-meta-target*"},
                                 allowedHeaders: new string[]                     { "x-ms-meta-12345675754564*" })
                }
            };

            Response <FileServiceProperties> properties3 = await FileServicesClient.SetServicePropertiesAsync(rgName, accountName, properties1.Value);

            //Validate CORS Rules
            Assert.AreEqual(properties1.Value.Cors.CorsRulesValue.Count, properties3.Value.Cors.CorsRulesValue.Count);
            for (int i = 0; i < properties1.Value.Cors.CorsRulesValue.Count; i++)
            {
                CorsRule putRule = properties1.Value.Cors.CorsRulesValue[i];
                CorsRule getRule = properties3.Value.Cors.CorsRulesValue[i];

                Assert.AreEqual(putRule.AllowedHeaders, getRule.AllowedHeaders);
                Assert.AreEqual(putRule.AllowedMethods, getRule.AllowedMethods);
                Assert.AreEqual(putRule.AllowedOrigins, getRule.AllowedOrigins);
                Assert.AreEqual(putRule.ExposedHeaders, getRule.ExposedHeaders);
                Assert.AreEqual(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
            }

            Response <FileServiceProperties> properties4 = await FileServicesClient.GetServicePropertiesAsync(rgName, accountName);

            //Validate CORS Rules
            Assert.AreEqual(properties1.Value.Cors.CorsRulesValue.Count, properties4.Value.Cors.CorsRulesValue.Count);
            for (int i = 0; i < properties1.Value.Cors.CorsRulesValue.Count; i++)
            {
                CorsRule putRule = properties1.Value.Cors.CorsRulesValue[i];
                CorsRule getRule = properties4.Value.Cors.CorsRulesValue[i];

                Assert.AreEqual(putRule.AllowedHeaders, getRule.AllowedHeaders);
                Assert.AreEqual(putRule.AllowedMethods, getRule.AllowedMethods);
                Assert.AreEqual(putRule.AllowedOrigins, getRule.AllowedOrigins);
                Assert.AreEqual(putRule.ExposedHeaders, getRule.ExposedHeaders);
                Assert.AreEqual(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
            }
        }
        internal static void AssertServicePropertiesAreEqual(ServiceProperties propsA, ServiceProperties propsB)
        {
            if (propsA.Logging != null && propsB.Logging != null)
            {
                Assert.AreEqual(propsA.Logging.LoggingOperations, propsB.Logging.LoggingOperations);
                Assert.AreEqual(propsA.Logging.RetentionDays, propsB.Logging.RetentionDays);
                Assert.AreEqual(propsA.Logging.Version, propsB.Logging.Version);
            }
            else
            {
                Assert.IsNull(propsA.Logging);
                Assert.IsNull(propsA.Logging);
            }

            if (propsA.HourMetrics != null && propsB.Logging != null)
            {
                Assert.AreEqual(propsA.HourMetrics.MetricsLevel, propsB.HourMetrics.MetricsLevel);
                Assert.AreEqual(propsA.HourMetrics.RetentionDays, propsB.HourMetrics.RetentionDays);
                Assert.AreEqual(propsA.HourMetrics.Version, propsB.HourMetrics.Version);
            }
            else
            {
                Assert.IsNull(propsA.HourMetrics);
                Assert.IsNull(propsB.HourMetrics);
            }

            if (propsA.MinuteMetrics != null && propsB.MinuteMetrics != null)
            {
                Assert.AreEqual(propsA.MinuteMetrics.MetricsLevel, propsB.MinuteMetrics.MetricsLevel);
                Assert.AreEqual(propsA.MinuteMetrics.RetentionDays, propsB.MinuteMetrics.RetentionDays);
                Assert.AreEqual(propsA.MinuteMetrics.Version, propsB.MinuteMetrics.Version);
            }
            else
            {
                Assert.IsNull(propsA.MinuteMetrics);
                Assert.IsNull(propsB.MinuteMetrics);
            }

            if (propsA.DefaultServiceVersion != null && propsB.DefaultServiceVersion != null)
            {
                Assert.AreEqual(propsA.DefaultServiceVersion, propsB.DefaultServiceVersion);
            }
            else
            {
                Assert.IsNull(propsA.DefaultServiceVersion);
                Assert.IsNull(propsB.DefaultServiceVersion);
            }

            if (propsA.Cors != null && propsB.Cors != null)
            {
                Assert.AreEqual(propsA.Cors.CorsRules.Count, propsB.Cors.CorsRules.Count);

                // Check that rules are equal and in the same order.
                for (int i = 0; i < propsA.Cors.CorsRules.Count; i++)
                {
                    CorsRule ruleA = propsA.Cors.CorsRules.ElementAt(i);
                    CorsRule ruleB = propsB.Cors.CorsRules.ElementAt(i);

                    Assert.IsTrue(
                        ruleA.AllowedOrigins.Count == ruleB.AllowedOrigins.Count &&
                        !ruleA.AllowedOrigins.Except(ruleB.AllowedOrigins).Any());

                    Assert.IsTrue(
                        ruleA.ExposedHeaders.Count == ruleB.ExposedHeaders.Count &&
                        !ruleA.ExposedHeaders.Except(ruleB.ExposedHeaders).Any());

                    Assert.IsTrue(
                        ruleA.AllowedHeaders.Count == ruleB.AllowedHeaders.Count &&
                        !ruleA.AllowedHeaders.Except(ruleB.AllowedHeaders).Any());

                    Assert.IsTrue(ruleA.AllowedMethods == ruleB.AllowedMethods);

                    Assert.IsTrue(ruleA.MaxAgeInSeconds == ruleB.MaxAgeInSeconds);
                }
            }
            else
            {
                Assert.IsNull(propsA.Cors);
                Assert.IsNull(propsB.Cors);
            }
        }
Ejemplo n.º 7
0
        public void TableServiceCorsTest()
        {
            var handler = new RecordedDelegatingHandler {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            using (MockContext context = MockContext.Start(this.GetType().FullName))
            {
                var resourcesClient   = StorageManagementTestUtilities.GetResourceManagementClient(context, handler);
                var storageMgmtClient = StorageManagementTestUtilities.GetStorageManagementClient(context, handler);

                // Create resource group
                var rgName = StorageManagementTestUtilities.CreateResourceGroup(resourcesClient);

                // Create storage account
                string accountName = TestUtilities.GenerateName("sto");
                var    parameters  = new StorageAccountCreateParameters
                {
                    Location = "eastus2euap",
                    Kind     = Kind.StorageV2,
                    Sku      = new Sku {
                        Name = SkuName.StandardLRS
                    },
                    LargeFileSharesState = LargeFileSharesState.Enabled
                };
                var account = storageMgmtClient.StorageAccounts.Create(rgName, accountName, parameters);

                // implement case
                try
                {
                    TableServiceProperties properties1 = storageMgmtClient.TableServices.GetServiceProperties(rgName, accountName);
                    Assert.Equal(0, properties1.Cors.CorsRulesProperty.Count);

                    CorsRules cors = new CorsRules();
                    cors.CorsRulesProperty = new List <CorsRule>();
                    cors.CorsRulesProperty.Add(new CorsRule()
                    {
                        AllowedHeaders  = new string[] { "x-ms-meta-abc", "x-ms-meta-data*", "x-ms-meta-target*" },
                        AllowedMethods  = new string[] { "GET", "HEAD", "POST", "OPTIONS", "MERGE", "PUT" },
                        AllowedOrigins  = new string[] { "http://www.contoso.com", "http://www.fabrikam.com" },
                        ExposedHeaders  = new string[] { "x-ms-meta-*" },
                        MaxAgeInSeconds = 100
                    });
                    cors.CorsRulesProperty.Add(new CorsRule()
                    {
                        AllowedHeaders  = new string[] { "*" },
                        AllowedMethods  = new string[] { "GET" },
                        AllowedOrigins  = new string[] { "*" },
                        ExposedHeaders  = new string[] { "*" },
                        MaxAgeInSeconds = 2
                    });
                    cors.CorsRulesProperty.Add(new CorsRule()
                    {
                        AllowedHeaders  = new string[] { "x-ms-meta-12345675754564*" },
                        AllowedMethods  = new string[] { "GET", "PUT", "CONNECT" },
                        AllowedOrigins  = new string[] { "http://www.abc23.com", "https://www.fabrikam.com/*" },
                        ExposedHeaders  = new string[] { "x-ms-meta-abc", "x-ms-meta-data*", "x -ms-meta-target*" },
                        MaxAgeInSeconds = 2000
                    });

                    TableServiceProperties properties3 = storageMgmtClient.TableServices.SetServiceProperties(rgName, accountName, cors);

                    //Validate CORS Rules
                    if (HttpMockServer.Mode == HttpRecorderMode.Record)
                    {
                        // Need wait for cors rules setting take effect when record case
                        System.Threading.Thread.Sleep(30000);
                    }
                    Assert.Equal(cors.CorsRulesProperty.Count, properties3.Cors.CorsRulesProperty.Count);
                    for (int i = 0; i < cors.CorsRulesProperty.Count; i++)
                    {
                        CorsRule putRule = cors.CorsRulesProperty[i];
                        CorsRule getRule = properties3.Cors.CorsRulesProperty[i];

                        Assert.Equal(putRule.AllowedHeaders, getRule.AllowedHeaders);
                        Assert.Equal(putRule.AllowedMethods, getRule.AllowedMethods);
                        Assert.Equal(putRule.AllowedOrigins, getRule.AllowedOrigins);
                        Assert.Equal(putRule.ExposedHeaders, getRule.ExposedHeaders);
                        Assert.Equal(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
                    }

                    TableServiceProperties properties4 = storageMgmtClient.TableServices.GetServiceProperties(rgName, accountName);

                    //Validate CORS Rules
                    Assert.Equal(cors.CorsRulesProperty.Count, properties4.Cors.CorsRulesProperty.Count);
                    for (int i = 0; i < cors.CorsRulesProperty.Count; i++)
                    {
                        CorsRule putRule = cors.CorsRulesProperty[i];
                        CorsRule getRule = properties4.Cors.CorsRulesProperty[i];

                        Assert.Equal(putRule.AllowedHeaders, getRule.AllowedHeaders);
                        Assert.Equal(putRule.AllowedMethods, getRule.AllowedMethods);
                        Assert.Equal(putRule.AllowedOrigins, getRule.AllowedOrigins);
                        Assert.Equal(putRule.ExposedHeaders, getRule.ExposedHeaders);
                        Assert.Equal(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
                    }
                }
                finally
                {
                    // clean up
                    storageMgmtClient.StorageAccounts.Delete(rgName, accountName);
                    resourcesClient.ResourceGroups.Delete(rgName);
                }
            }
        }
Ejemplo n.º 8
0
        // Constructor - create from an Azure CorsRule object.

        public CORSRule(CorsRule rule)
        {
            // Retrieve allowed origins.

            if (rule.AllowedOrigins != null)
            {
                String origins = String.Empty;
                foreach (String origin in rule.AllowedOrigins)
                {
                    if (origins.Length > 0)
                    {
                        origins = origins + ",";
                    }
                    origins = origins + origin;
                }
                this.AllowedOrigins = origins;
            }

            // Retrieve allowed headers.

            if (rule.AllowedHeaders != null)
            {
                String headers = String.Empty;
                foreach (String header in rule.AllowedHeaders)
                {
                    if (headers.Length > 0)
                    {
                        headers = headers + ",";
                    }
                    headers = headers + header;
                }
                this.AllowedHeaders = headers;
            }

            // Retrieve exposed headers.

            if (rule.ExposedHeaders != null)
            {
                String headers = String.Empty;
                foreach (String header in rule.ExposedHeaders)
                {
                    if (headers.Length > 0)
                    {
                        headers = headers + ",";
                    }
                    headers = headers + header;
                }
                this.ExposedHeaders = headers;
            }

            // Retrieve allowed methods.

            String methods = String.Empty;

            if ((rule.AllowedMethods & CorsHttpMethods.Connect) == CorsHttpMethods.Connect)
            {
                methods = methods + "CONNECT,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Delete) == CorsHttpMethods.Delete)
            {
                methods = methods + "DELETE,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Get) == CorsHttpMethods.Get)
            {
                methods = methods + "GET,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Head) == CorsHttpMethods.Head)
            {
                methods = methods + "HEAD,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Merge) == CorsHttpMethods.Merge)
            {
                methods = methods + "MERGE,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.None) == CorsHttpMethods.None)
            {
                methods = methods + "NONE,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Options) == CorsHttpMethods.Options)
            {
                methods = methods + "OPTIONS,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Post) == CorsHttpMethods.Post)
            {
                methods = methods + "POST,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Put) == CorsHttpMethods.Put)
            {
                methods = methods + "PUT,";
            }
            ;
            if ((rule.AllowedMethods & CorsHttpMethods.Trace) == CorsHttpMethods.Trace)
            {
                methods = methods + "TRACE,";
            }
            ;

            if (methods.Length > 0 && methods.EndsWith(","))
            {
                methods = methods.Substring(0, methods.Length - 1);
            }

            this.AllowedMethods = methods;

            this.MaxAgeInSeconds = rule.MaxAgeInSeconds.ToString();
        }
Ejemplo n.º 9
0
        public async Task BlobServiceCors()
        {
            BlobServiceData blobServiceData = new BlobServiceData()
            {
                DeleteRetentionPolicy = new DeleteRetentionPolicy()
                {
                    Enabled = true,
                    Days    = 300,
                },
                DefaultServiceVersion = "2017-04-17",
                Cors = new CorsRules()
                {
                    CorsRulesValue =
                    {
                        new CorsRule(new[] { "http://www.contoso.com",       "http://www.fabrikam.com"       },
                                     new[] { CorsRuleAllowedMethodsItem.GET, CorsRuleAllowedMethodsItem.PUT  },
                                     100,
                                     new[] { "x-ms-meta-*" },
                                     new[] { "x-ms-meta-abc",                "x-ms-meta-data*", "x-ms-meta-target*"}),
                        new CorsRule(new[] { "*" },
                                     new[] { CorsRuleAllowedMethodsItem.GET },
                                     2,
                                     new[] { "*" },
                                     new[] { "*" }),
                        new CorsRule(new[] { "http://www.abc23.com",         "https://www.fabrikam.com/*"    },
                                     new[] { CorsRuleAllowedMethodsItem.GET, CorsRuleAllowedMethodsItem.PUT, CorsRuleAllowedMethodsItem.Post},
                                     2000,
                                     new[] { "x-ms-meta-12345675754564*" },
                                     new[] { "x-ms-meta-abc",                "x-ms-meta-data*", "x-ms-meta-target*"})
                    }
                }
            };

            _blobService = (await _blobService.CreateOrUpdateAsync(WaitUntil.Completed, blobServiceData)).Value;

            Assert.AreEqual(blobServiceData.DeleteRetentionPolicy.Enabled, _blobService.Data.DeleteRetentionPolicy.Enabled);
            Assert.AreEqual(blobServiceData.DeleteRetentionPolicy.Days, _blobService.Data.DeleteRetentionPolicy.Days);
            Assert.AreEqual(blobServiceData.DefaultServiceVersion, _blobService.Data.DefaultServiceVersion);

            //validate CORS rules
            Assert.AreEqual(blobServiceData.Cors.CorsRulesValue.Count, _blobService.Data.Cors.CorsRulesValue.Count);
            for (int i = 0; i < blobServiceData.Cors.CorsRulesValue.Count; i++)
            {
                CorsRule putRule = blobServiceData.Cors.CorsRulesValue[i];
                CorsRule getRule = _blobService.Data.Cors.CorsRulesValue[i];

                Assert.AreEqual(putRule.AllowedHeaders, getRule.AllowedHeaders);
                Assert.AreEqual(putRule.AllowedMethods, getRule.AllowedMethods);
                Assert.AreEqual(putRule.AllowedOrigins, getRule.AllowedOrigins);
                Assert.AreEqual(putRule.ExposedHeaders, getRule.ExposedHeaders);
                Assert.AreEqual(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
            }

            _blobService = await _blobService.GetAsync();

            Assert.AreEqual(blobServiceData.DeleteRetentionPolicy.Enabled, _blobService.Data.DeleteRetentionPolicy.Enabled);
            Assert.AreEqual(blobServiceData.DeleteRetentionPolicy.Days, _blobService.Data.DeleteRetentionPolicy.Days);
            Assert.AreEqual(blobServiceData.DefaultServiceVersion, _blobService.Data.DefaultServiceVersion);

            //validate CORS rules
            Assert.AreEqual(blobServiceData.Cors.CorsRulesValue.Count, _blobService.Data.Cors.CorsRulesValue.Count);
            for (int i = 0; i < blobServiceData.Cors.CorsRulesValue.Count; i++)
            {
                CorsRule putRule = blobServiceData.Cors.CorsRulesValue[i];
                CorsRule getRule = _blobService.Data.Cors.CorsRulesValue[i];

                Assert.AreEqual(putRule.AllowedHeaders, getRule.AllowedHeaders);
                Assert.AreEqual(putRule.AllowedMethods, getRule.AllowedMethods);
                Assert.AreEqual(putRule.AllowedOrigins, getRule.AllowedOrigins);
                Assert.AreEqual(putRule.ExposedHeaders, getRule.ExposedHeaders);
                Assert.AreEqual(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
            }
        }
Ejemplo n.º 10
0
        public override void ExecuteCmdlet()
        {
            if (ServiceType != StorageServiceType.Table)
            {
                ServiceProperties serviceProperties = new ServiceProperties();
                serviceProperties.Clean();
                serviceProperties.Cors = new CorsProperties();

                foreach (var corsRuleObject in this.CorsRules)
                {
                    CorsRule corsRule = new CorsRule();
                    corsRule.AllowedHeaders  = corsRuleObject.AllowedHeaders;
                    corsRule.AllowedOrigins  = corsRuleObject.AllowedOrigins;
                    corsRule.ExposedHeaders  = corsRuleObject.ExposedHeaders;
                    corsRule.MaxAgeInSeconds = corsRuleObject.MaxAgeInSeconds;
                    this.SetAllowedMethods(corsRule, corsRuleObject.AllowedMethods);
                    serviceProperties.Cors.CorsRules.Add(corsRule);
                }

                try
                {
                    Channel.SetStorageServiceProperties(ServiceType, serviceProperties,
                                                        GetRequestOptions(ServiceType), OperationContext);
                }
                catch (StorageException se)
                {
                    if ((null != se.RequestInformation) &&
                        ((int)HttpStatusCode.BadRequest == se.RequestInformation.HttpStatusCode) &&
                        (null != se.RequestInformation.ExtendedErrorInformation) &&
                        (string.Equals(InvalidXMLNodeValueError, se.RequestInformation.ErrorCode, StringComparison.OrdinalIgnoreCase) ||
                         string.Equals(InvalidXMLDocError, se.RequestInformation.ErrorCode, StringComparison.OrdinalIgnoreCase)))
                    {
                        throw new InvalidOperationException(Resources.CORSRuleError);
                    }
                    else
                    {
                        throw;
                    }
                }
            }
            else //Table use old XSCL
            {
                XTable.ServiceProperties serviceProperties = new XTable.ServiceProperties();
                serviceProperties.Clean();
                serviceProperties.Cors = new XTable.CorsProperties();

                foreach (var corsRuleObject in this.CorsRules)
                {
                    XTable.CorsRule corsRule = new XTable.CorsRule();
                    corsRule.AllowedHeaders  = corsRuleObject.AllowedHeaders;
                    corsRule.AllowedOrigins  = corsRuleObject.AllowedOrigins;
                    corsRule.ExposedHeaders  = corsRuleObject.ExposedHeaders;
                    corsRule.MaxAgeInSeconds = corsRuleObject.MaxAgeInSeconds;
                    this.SetAllowedMethods(corsRule, corsRuleObject.AllowedMethods);
                    serviceProperties.Cors.CorsRules.Add(corsRule);
                }

                try
                {
                    StorageTableManagement tableChannel = new StorageTableManagement(Channel.StorageContext);
                    tableChannel.SetStorageTableServiceProperties(serviceProperties,
                                                                  GetTableRequestOptions(), TableOperationContext);
                }
                catch (XTable.StorageException se)
                {
                    if ((null != se.RequestInformation) &&
                        ((int)HttpStatusCode.BadRequest == se.RequestInformation.HttpStatusCode) &&
                        (null != se.RequestInformation.ExtendedErrorInformation) &&
                        (string.Equals(InvalidXMLNodeValueError, se.RequestInformation.ErrorCode, StringComparison.OrdinalIgnoreCase) ||
                         string.Equals(InvalidXMLDocError, se.RequestInformation.ErrorCode, StringComparison.OrdinalIgnoreCase)))
                    {
                        throw new InvalidOperationException(Resources.CORSRuleError);
                    }
                    else
                    {
                        throw;
                    }
                }
            }

            if (PassThru)
            {
                WriteObject(this.CorsRules);
            }
        }
Ejemplo n.º 11
0
        public async Task EnableCORSAsync()
        {
            CorsHttpMethods allowedMethods = CorsHttpMethods.None;

            allowedMethods |= CorsHttpMethods.Get;
            allowedMethods |= CorsHttpMethods.Put;
            allowedMethods |= CorsHttpMethods.Post;
            allowedMethods |= CorsHttpMethods.Delete;
            allowedMethods |= CorsHttpMethods.Options;

            var          delimiter      = new[] { "," };
            var          corsRule       = new CorsRule();
            const string AllowedOrigins = "*";
            const string AllowedHeaders = "*";
            const string ExposedHeaders = "";

            var allAllowedOrigin = AllowedOrigins.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
            var allExpHeaders    = ExposedHeaders.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
            var allAllowHeaders  = AllowedHeaders.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);

            var corsAllowedOrigin = new List <string>();

            foreach (var item in allAllowedOrigin)
            {
                if (!string.IsNullOrWhiteSpace(item))
                {
                    corsAllowedOrigin.Add(item.Trim());
                }
            }

            var corsExposedHeaders = new List <string>();

            foreach (var item in allExpHeaders)
            {
                if (!string.IsNullOrWhiteSpace(item))
                {
                    corsExposedHeaders.Add(item.Trim());
                }
            }

            var corsAllowHeaders = new List <string>();

            foreach (var item in allAllowHeaders)
            {
                if (!string.IsNullOrWhiteSpace(item))
                {
                    corsAllowHeaders.Add(item.Trim());
                }
            }

            corsRule.MaxAgeInSeconds = 200;
            corsRule.AllowedMethods  = allowedMethods;
            corsRule.AllowedHeaders  = corsAllowHeaders;
            corsRule.AllowedOrigins  = corsAllowedOrigin;
            corsRule.ExposedHeaders  = corsExposedHeaders;
            var serviceProperties = await this.blobClient.GetServicePropertiesAsync();

            serviceProperties.Cors.CorsRules.Clear();
            serviceProperties.Cors.CorsRules.Add(corsRule);
            await this.blobClient.SetServicePropertiesAsync(serviceProperties);
        }
Ejemplo n.º 12
0
        public void GetServiceProperties_AllService_AllProperties()
        {
            //prepare the service properties to set and get
            PSCorsRule[] corsRules = CORSRuleUtil.GetRandomValidCORSRules(random.Next(1, 5));

            Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties serviceProperties = new Microsoft.WindowsAzure.Storage.Shared.Protocol.ServiceProperties();
            serviceProperties.Clean();
            serviceProperties.Cors = new CorsProperties();

            foreach (var rule in corsRules)
            {
                CorsRule corsRule = new CorsRule()
                {
                    AllowedHeaders  = rule.AllowedHeaders,
                    AllowedOrigins  = rule.AllowedOrigins,
                    ExposedHeaders  = rule.ExposedHeaders,
                    MaxAgeInSeconds = rule.MaxAgeInSeconds,
                };
                SetAllowedMethods(corsRule, rule.AllowedMethods);
                serviceProperties.Cors.CorsRules.Add(corsRule);
            }
            serviceProperties.HourMetrics = new MetricsProperties("1.0");
            serviceProperties.HourMetrics.MetricsLevel    = MetricsLevel.ServiceAndApi;
            serviceProperties.HourMetrics.RetentionDays   = 1;
            serviceProperties.MinuteMetrics               = new MetricsProperties("1.0");
            serviceProperties.MinuteMetrics.MetricsLevel  = MetricsLevel.Service;
            serviceProperties.MinuteMetrics.RetentionDays = 3;

            serviceProperties.Logging = new LoggingProperties("1.0");
            serviceProperties.Logging.LoggingOperations = LoggingOperations.All;
            serviceProperties.Logging.RetentionDays     = 5;


            foreach (string servicetype in ValidServiceType)
            {
                Constants.ServiceType service = Constants.ServiceType.Blob;
                Enum.TryParse <Constants.ServiceType>(servicetype, true, out service);
                if (service == Constants.ServiceType.Blob) //only Blob support default service version
                {
                    serviceProperties.DefaultServiceVersion = "2017-04-17";

                    serviceProperties.DeleteRetentionPolicy               = new DeleteRetentionPolicy();
                    serviceProperties.DeleteRetentionPolicy.Enabled       = true;
                    serviceProperties.DeleteRetentionPolicy.RetentionDays = 10;
                }

                //Set Service Properties with XSCL API
                ServiceCORSRule.SetSerivceProperties(service, serviceProperties);

                //Get Service Properties with PowerShell
                PSSeriviceProperties properties = GetServicePropertiesFromPSH(service);

                //Validate Cors, metric, logging
                CORSRuleUtil.ValidateCORSRules(corsRules, properties.Cors);

                if (service != Constants.ServiceType.File) // File service don't support logging
                {
                    ExpectEqual(serviceProperties.Logging.Version, properties.Logging.Version, "Logging version");
                    ExpectEqual(serviceProperties.Logging.LoggingOperations.ToString(), properties.Logging.LoggingOperations.ToString(), "Logging Operations");
                    ExpectEqual(serviceProperties.Logging.RetentionDays.Value, properties.Logging.RetentionDays.Value, "Logging RetentionDays");
                }

                ExpectEqual(serviceProperties.HourMetrics.Version, properties.HourMetrics.Version, "HourMetrics Version");
                ExpectEqual(serviceProperties.HourMetrics.MetricsLevel.ToString(), properties.HourMetrics.MetricsLevel.ToString(), "HourMetrics MetricsLevel");
                ExpectEqual(serviceProperties.HourMetrics.RetentionDays.Value, properties.HourMetrics.RetentionDays.Value, "HourMetrics RetentionDays");

                ExpectEqual(serviceProperties.MinuteMetrics.Version, properties.MinuteMetrics.Version, "MinuteMetrics Version");
                ExpectEqual(serviceProperties.MinuteMetrics.MetricsLevel.ToString(), properties.MinuteMetrics.MetricsLevel.ToString(), "MinuteMetrics MetricsLevel");
                ExpectEqual(serviceProperties.MinuteMetrics.RetentionDays.Value, properties.MinuteMetrics.RetentionDays.Value, "MinuteMetrics RetentionDays");


                if (service == Constants.ServiceType.Blob)
                {
                    ExpectEqual(serviceProperties.DefaultServiceVersion, properties.DefaultServiceVersion, "DefaultServiceVersion");

                    ExpectEqual(serviceProperties.DeleteRetentionPolicy.Enabled.ToString(), properties.DeleteRetentionPolicy.Enabled.ToString(), "DeleteRetentionPolicy Enabled");
                    ExpectEqual(serviceProperties.DeleteRetentionPolicy.RetentionDays.Value, properties.DeleteRetentionPolicy.RetentionDays.Value, "DeleteRetentionPolicy RetentionDays");

                    serviceProperties.DeleteRetentionPolicy = null;
                    serviceProperties.DefaultServiceVersion = null;
                }
            }
        }
        public async Task RunQueueStorageOperationsAsync()
        {
            // string queueName = "queue-" + System.Guid.NewGuid().ToString();
            string queueName = "queue";
            Console.WriteLine();
            CloudStorageAccount storageAccount = Common.CreateStorageAccountFromConnectionString(Microsoft.Azure.CloudConfigurationManager.GetSetting("StorageConnectionString"));
            CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
            CloudQueue queue = queueClient.GetQueueReference(queueName);
            try
            {
                await queue.CreateIfNotExistsAsync();
            }
            catch
            {
                Console.WriteLine("If you are running with the default configuration please make sure you have started the storage emulator.  Press the Windows key and type Azure Storage to select and run it from the list of applications - then restart the sample.");
                Console.ReadLine();
                throw;
            }
            Console.WriteLine("QUEUE created with NAME : " + queue.Name.ToString() + "\n");
            Console.WriteLine("*** MENU ***");
            Console.WriteLine("1 : Insert a message into a queue");
            Console.WriteLine("2 : See messages in a queue");
            Console.WriteLine("3 : De-queue the next message");
            Console.WriteLine("4 : Change the contents of a queued message");
            Console.WriteLine("5 : Enqueue a limited number of messages");
            Console.WriteLine("6 : Get the queue length");
            Console.WriteLine("7 : Delete the Queue");
            Console.WriteLine("8 : listing and comparing queues ");
            Console.WriteLine("9 : Get Service Properties of Queue");
            Console.WriteLine("10 : adding and restoring CORS rules sample");
            Console.WriteLine("11 : QUEUE MetaData");
            Console.WriteLine("12 : exit app");

            var selectedValue = Console.ReadLine();
            Regex regex = new Regex("^[0-9]+$");
            if (regex.IsMatch(selectedValue.ToString()))
            {
                int selection = Convert.ToInt32(selectedValue);
                while (selection != 0)
                {
                    switch (selection)
                    {
                        case 1: //Insert a message into a queue
                            Console.WriteLine("Enter a message");
                            await queue.AddMessageAsync(new CloudQueueMessage(Console.ReadLine()));
                            break;
                        case 2: //Peek messages in a queue
                            CloudQueueMessage peekedMessage = await queue.PeekMessageAsync();
                            

                           
                            if (peekedMessage != null)
                            {
                                Console.WriteLine("The peeked message is: {0}", peekedMessage.AsString);
                            }
                            else
                            {
                                Console.WriteLine("No messages exist");
                            }
                            break;
                        case 3: //De-queue the next message
                            CloudQueueMessage message = await queue.GetMessageAsync();
                            if (message != null)
                            {
                                Console.WriteLine("Processing & deleting message with content: {0}", message.AsString);
                                await queue.DeleteMessageAsync(message);
                            }
                            else
                            {
                                Console.WriteLine("No messages exist");
                            }
                            break;
                        case 4: //Change the contents of a queued message
                            CloudQueueMessage message1 = await queue.GetMessageAsync();
                            if (message1 != null)
                            {
                                Console.WriteLine("Enter content to be updated !");
                                message1.SetMessageContent(Console.ReadLine().ToString());
                                await queue.UpdateMessageAsync(message1, TimeSpan.Zero, MessageUpdateFields.Content | MessageUpdateFields.Visibility);
                                CloudQueueMessage peekedMessage1 = await queue.PeekMessageAsync();
                                if (peekedMessage1 != null)
                                {
                                    Console.WriteLine("The modified message is: {0}", peekedMessage1.AsString);
                                }
                            }
                            else
                            {
                                Console.WriteLine("No messages exist");
                            }
                            break;
                        case 5: //Enqueue a limited number of messages
                            Console.WriteLine("Input the count of the messages : ");
                            var messageCount = Console.ReadLine();
                            if (regex.IsMatch(messageCount.ToString()))
                            {
                                for (int i = 0; i < Convert.ToInt32(messageCount); i++)
                                {
                                    Console.WriteLine("Enter the message no : " + i);
                                    var newMsg = Console.ReadLine();
                                    await queue.AddMessageAsync(new CloudQueueMessage(newMsg));
                                }
                            }
                            else
                            {
                                Console.WriteLine("Please Input a number");
                            }
                            break;
                        case 6: //Get the queue length
                            queue.FetchAttributes();
                            int? count = queue.ApproximateMessageCount;
                            if (count != null && count > 0)
                            {
                                Console.WriteLine("Message count = " + count);
                            }
                            else
                            {
                                Console.WriteLine("No messages exist");
                            }
                            break;
                        case 7: //Delete the Queue
                            await queue.DeleteIfExistsAsync();
                            Console.WriteLine("Queue deleted !!");
                            break;
                        case 8: //listing and comparing queues
                            Console.WriteLine("Enter the no of queues u want to create");
                            var queueCount = Console.ReadLine();
                            List<string> lstQueueNames = new List<string>();
                            if (regex.IsMatch(queueCount.ToString()))
                            {
                                for (int i = 0; i < Convert.ToInt32(queueCount); i++)
                                {
                                    string qName = queueName + "-ls-" + i;
                                    lstQueueNames.Add(qName);

                                    CloudQueue cloudQueue = queueClient.GetQueueReference(queueName);
                                    try
                                    {
                                        await cloudQueue.CreateIfNotExistsAsync();
                                    }
                                    catch (StorageException exStorage)
                                    {
                                        Common.WriteException(exStorage);
                                        Console.WriteLine(
                                            "Please make sure your storage account is specified correctly in the app.config - then restart the sample.");
                                        Console.WriteLine("Press any key to exit");
                                        Console.ReadLine();
                                        throw;
                                    }
                                    catch (Exception ex)
                                    {
                                        Console.WriteLine(" Exception thrown while creating queue.");
                                        Common.WriteException(ex);
                                        throw;
                                    }
                                }
                                QueueContinuationToken queueContinuationToken = null;
                                List<CloudQueue> lstCloudQueues = new List<CloudQueue>();
                                do
                                {
                                    QueueResultSegment queueResultSegment = await queueClient.ListQueuesSegmentedAsync(queueName, queueContinuationToken);
                                    queueContinuationToken = queueResultSegment.ContinuationToken;
                                    lstCloudQueues.AddRange(queueResultSegment.Results);
                                }
                                while (queueContinuationToken != null);

                                foreach (string qNames in lstQueueNames)
                                {
                                    CloudQueue cloudQueue = queueClient.GetQueueReference(qNames);
                                    cloudQueue.DeleteIfExists();
                                }
                            }
                            else
                            {
                                Console.WriteLine("Enter a numeric value");
                            }
                            break;
                        case 9: // get the service properties - sample only
                            ServiceProperties orignalServiceProperties = await queueClient.GetServicePropertiesAsync();
                            Console.WriteLine("Original service properties :");
                            Console.WriteLine("Logging operations : " + orignalServiceProperties.Logging.LoggingOperations);
                            Console.WriteLine("Logging RetentionDays : " + orignalServiceProperties.Logging.RetentionDays);
                            Console.WriteLine("Logging Version : " + orignalServiceProperties.Logging.Version);
                            Console.WriteLine("HourMetrics MetricsLevel : " + orignalServiceProperties.HourMetrics.MetricsLevel);
                            Console.WriteLine("HourMetrics Retention Days : " + orignalServiceProperties.HourMetrics.RetentionDays);
                            Console.WriteLine("HourMetrics Version : " + orignalServiceProperties.HourMetrics.Version);
                            Console.WriteLine("MinuteMetrics MetricsLevel : " + orignalServiceProperties.MinuteMetrics.MetricsLevel);
                            Console.WriteLine("MinuteMetrics Retention Days : " + orignalServiceProperties.MinuteMetrics.RetentionDays);
                            Console.WriteLine("MinuteMetrics Version : " + orignalServiceProperties.MinuteMetrics.Version);
                            try
                            {
                                Console.WriteLine();
                                Console.WriteLine("After changing values");
                                //change the service properties
                                ServiceProperties serviceProperties = await queueClient.GetServicePropertiesAsync();
                                serviceProperties.Logging.LoggingOperations = LoggingOperations.Read | LoggingOperations.Write;
                                serviceProperties.Logging.RetentionDays = 10;
                                serviceProperties.Logging.Version = Constants.AnalyticsConstants.LoggingVersionV1;

                                serviceProperties.HourMetrics.MetricsLevel = MetricsLevel.Service;
                                serviceProperties.HourMetrics.RetentionDays = 10;
                                serviceProperties.HourMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;

                                serviceProperties.MinuteMetrics.MetricsLevel = MetricsLevel.Service;
                                serviceProperties.MinuteMetrics.RetentionDays = 10;
                                serviceProperties.MinuteMetrics.Version = Constants.AnalyticsConstants.MetricsVersionV1;

                                await queueClient.SetServicePropertiesAsync(serviceProperties);

                                Console.WriteLine("Logging operations : " + serviceProperties.Logging.LoggingOperations);
                                Console.WriteLine("Logging RetentionDays : " + serviceProperties.Logging.RetentionDays);
                                Console.WriteLine("Logging Version : " + serviceProperties.Logging.Version);
                                Console.WriteLine("HourMetrics MetricsLevel : " + serviceProperties.HourMetrics.MetricsLevel);
                                Console.WriteLine("HourMetrics Retention Days : " + serviceProperties.HourMetrics.RetentionDays);
                                Console.WriteLine("HourMetrics Version : " + serviceProperties.HourMetrics.Version);
                                Console.WriteLine("MinuteMetrics MetricsLevel : " + serviceProperties.MinuteMetrics.MetricsLevel);
                                Console.WriteLine("MinuteMetrics Retention Days : " + serviceProperties.MinuteMetrics.RetentionDays);
                                Console.WriteLine("MinuteMetrics Version : " + serviceProperties.MinuteMetrics.Version);
                            }
                            finally
                            {

                                await queueClient.SetServicePropertiesAsync(orignalServiceProperties);
                            }
                            break;
                        case 10:
                            //adding and restoring CORS rules
                            ServiceProperties orignalServicePropertiesCors = await queueClient.GetServicePropertiesAsync();
                            Console.WriteLine("Original service properties :");
                            Console.WriteLine("existing CORS count :" + orignalServicePropertiesCors.Cors.CorsRules.Count);
                            try
                            {
                                Console.WriteLine();
                                Console.WriteLine("adding CORS Rules");
                                Console.WriteLine("AllowedHeaders = any");
                                Console.WriteLine("AllowedMethods = Get");
                                Console.WriteLine("AllowedOrigins = any");
                                Console.WriteLine("ExposedHeaders = any");
                                Console.WriteLine("MaxAgeInSeconds = 3600");
                                // * for any
                                CorsRule corsRule = new CorsRule
                                {
                                    AllowedHeaders = new List<string> { "*" },
                                    AllowedMethods = CorsHttpMethods.Get,
                                    AllowedOrigins = new List<string> { "*" },
                                    ExposedHeaders = new List<string> { "*" },
                                    MaxAgeInSeconds = 3600
                                };
                                //change the service properties
                                ServiceProperties serviceProperties = await queueClient.GetServicePropertiesAsync();
                                serviceProperties.Cors.CorsRules.Add(corsRule);
                                Console.WriteLine("new CORS count :" + serviceProperties.Cors.CorsRules.Count);
                                await queueClient.SetServicePropertiesAsync(serviceProperties);
                            }
                            finally
                            {
                                await queueClient.SetServicePropertiesAsync(orignalServicePropertiesCors);
                                Console.WriteLine("restoring CORS rules :" + orignalServicePropertiesCors.Cors.CorsRules.Count);
                            }
                            break;
                        case 11: //QUEUE MetaData
                            string quName = "q-" + Guid.NewGuid();

                            Console.WriteLine("Setting queue metadata");
                            queue.Metadata.Add("key1", "value1");
                            queue.Metadata.Add("key2", "value2");

                            Console.WriteLine("Creating queue with name {0}", quName);
                            await queue.CreateIfNotExistsAsync();

                            await queue.FetchAttributesAsync();
                            Console.WriteLine("Get queue metadata:");
                            foreach (var keyValue in queue.Metadata)
                            {
                                Console.WriteLine("  {0}: {1}", keyValue.Key, keyValue.Value);
                            }
                            Console.WriteLine("Deleting queue with name {0}", quName);
                            queue.DeleteIfExists();
                            break;
                        case 12:
                            await queue.DeleteIfExistsAsync();
                            Environment.Exit(0);
                            break;
                        default: Environment.Exit(0); break;
                    }
                    Console.WriteLine();
                    Console.WriteLine("Select another option or press 0 to exit");
                    var newSelection = Console.ReadLine();
                    if (regex.IsMatch(newSelection.ToString()))
                    {
                        selection = Convert.ToInt32(newSelection);
                    }
                    else
                    {
                        Console.WriteLine("Please select a number");
                        Console.Clear();
                        await RunQueueStorageOperationsAsync();
                    }
                    Console.WriteLine();
                }
            }
            else
            {
                Console.WriteLine("Please select a number");
                Console.Clear();
                await RunQueueStorageOperationsAsync();
            }
        }
Ejemplo n.º 14
0
        public void CloudTableTestCorsMaxHeaders()
        {
            CorsRule ruleManyHeaders = new CorsRule()
            {
                AllowedOrigins = new List <string>()
                {
                    "www.xyz.com"
                },
                AllowedMethods = CorsHttpMethods.Get,
                AllowedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-target*",
                    "x-ms-meta-other*"
                },
                ExposedHeaders =
                    new List <string>()
                {
                    "x-ms-meta-data*",
                    "x-ms-meta-source*"
                }
            };

            // Add maximum number of non-prefixed headers
            for (int i = 0; i < 64; i++)
            {
                ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-" + i);
                ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-" + i);
            }

            CloudTableClient client = GenerateCloudTableClient();

            this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            });

            // Test with too many Exposed Headers (65)
            ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-toomany");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of 64 literal exposed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.ExposedHeaders.Remove("x-ms-meta-toomany");

            // Test with too many Allowed Headers (65)
            ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-toomany");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of 64 literal allowed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.AllowedHeaders.Remove("x-ms-meta-toomany");

            // Test with too many Exposed Prefixed Headers (three)
            ruleManyHeaders.ExposedHeaders.Add("x-ms-meta-toomany*");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of two prefixed exposed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.ExposedHeaders.Remove("x-ms-meta-toomany*");

            // Test with too many Allowed Prefixed Headers (three)
            ruleManyHeaders.AllowedHeaders.Add("x-ms-meta-toomany*");

            TestHelper.ExpectedException(
                () => this.TestCorsRules(client, new List <CorsRule>()
            {
                ruleManyHeaders
            }),
                "A maximum of two prefixed allowed headers are allowed.",
                HttpStatusCode.BadRequest,
                "InvalidXmlNodeValue");

            ruleManyHeaders.AllowedHeaders.Remove("x-ms-meta-toomany*");
        }
Ejemplo n.º 15
0
        public void BlobServiceCorsTest()
        {
            var handler = new RecordedDelegatingHandler {
                StatusCodeToReturn = HttpStatusCode.OK
            };

            using (MockContext context = MockContext.Start(this.GetType()))
            {
                var resourcesClient   = StorageManagementTestUtilities.GetResourceManagementClient(context, handler);
                var storageMgmtClient = StorageManagementTestUtilities.GetStorageManagementClient(context, handler);

                // Create resource group
                var rgName = StorageManagementTestUtilities.CreateResourceGroup(resourcesClient);

                // Create storage account
                string accountName = TestUtilities.GenerateName("sto");
                var    parameters  = StorageManagementTestUtilities.GetDefaultStorageAccountParameters();
                var    account     = storageMgmtClient.StorageAccounts.Create(rgName, accountName, parameters);
                StorageManagementTestUtilities.VerifyAccountProperties(account, true);

                // implement case
                try
                {
                    BlobServiceProperties properties1 = storageMgmtClient.BlobServices.GetServiceProperties(rgName, accountName);
                    BlobServiceProperties properties2 = new BlobServiceProperties();
                    properties2.DeleteRetentionPolicy         = new DeleteRetentionPolicy();
                    properties2.DeleteRetentionPolicy.Enabled = true;
                    properties2.DeleteRetentionPolicy.Days    = 300;
                    properties2.DefaultServiceVersion         = "2017-04-17";
                    properties2.Cors = new CorsRules();
                    properties2.Cors.CorsRulesProperty = new List <CorsRule>();
                    properties2.Cors.CorsRulesProperty.Add(new CorsRule()
                    {
                        AllowedHeaders  = new string[] { "x-ms-meta-abc", "x-ms-meta-data*", "x-ms-meta-target*" },
                        AllowedMethods  = new string[] { "GET", "HEAD", "POST", "OPTIONS", "MERGE", "PUT" },
                        AllowedOrigins  = new string[] { "http://www.contoso.com", "http://www.fabrikam.com" },
                        ExposedHeaders  = new string[] { "x-ms-meta-*" },
                        MaxAgeInSeconds = 100
                    });
                    properties2.Cors.CorsRulesProperty.Add(new CorsRule()
                    {
                        AllowedHeaders  = new string[] { "*" },
                        AllowedMethods  = new string[] { "GET" },
                        AllowedOrigins  = new string[] { "*" },
                        ExposedHeaders  = new string[] { "*" },
                        MaxAgeInSeconds = 2
                    });
                    properties2.Cors.CorsRulesProperty.Add(new CorsRule()
                    {
                        AllowedHeaders  = new string[] { "x-ms-meta-12345675754564*" },
                        AllowedMethods  = new string[] { "GET", "PUT", "CONNECT" },
                        AllowedOrigins  = new string[] { "http://www.abc23.com", "https://www.fabrikam.com/*" },
                        ExposedHeaders  = new string[] { "x-ms-meta-abc", "x-ms-meta-data*", "x -ms-meta-target*" },
                        MaxAgeInSeconds = 2000
                    });

                    BlobServiceProperties properties3 = storageMgmtClient.BlobServices.SetServiceProperties(rgName, accountName, properties2);
                    Assert.True(properties3.DeleteRetentionPolicy.Enabled);
                    Assert.Equal(300, properties3.DeleteRetentionPolicy.Days);
                    Assert.Equal("2017-04-17", properties3.DefaultServiceVersion);

                    //Validate CORS Rules
                    Assert.Equal(properties2.Cors.CorsRulesProperty.Count, properties3.Cors.CorsRulesProperty.Count);
                    for (int i = 0; i < properties2.Cors.CorsRulesProperty.Count; i++)
                    {
                        CorsRule putRule = properties2.Cors.CorsRulesProperty[i];
                        CorsRule getRule = properties3.Cors.CorsRulesProperty[i];

                        Assert.Equal(putRule.AllowedHeaders, getRule.AllowedHeaders);
                        Assert.Equal(putRule.AllowedMethods, getRule.AllowedMethods);
                        Assert.Equal(putRule.AllowedOrigins, getRule.AllowedOrigins);
                        Assert.Equal(putRule.ExposedHeaders, getRule.ExposedHeaders);
                        Assert.Equal(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
                    }

                    BlobServiceProperties properties4 = storageMgmtClient.BlobServices.GetServiceProperties(rgName, accountName);
                    Assert.True(properties4.DeleteRetentionPolicy.Enabled);
                    Assert.Equal(300, properties4.DeleteRetentionPolicy.Days);
                    Assert.Equal("2017-04-17", properties4.DefaultServiceVersion);

                    //Validate CORS Rules
                    Assert.Equal(properties2.Cors.CorsRulesProperty.Count, properties4.Cors.CorsRulesProperty.Count);
                    for (int i = 0; i < properties2.Cors.CorsRulesProperty.Count; i++)
                    {
                        CorsRule putRule = properties2.Cors.CorsRulesProperty[i];
                        CorsRule getRule = properties4.Cors.CorsRulesProperty[i];

                        Assert.Equal(putRule.AllowedHeaders, getRule.AllowedHeaders);
                        Assert.Equal(putRule.AllowedMethods, getRule.AllowedMethods);
                        Assert.Equal(putRule.AllowedOrigins, getRule.AllowedOrigins);
                        Assert.Equal(putRule.ExposedHeaders, getRule.ExposedHeaders);
                        Assert.Equal(putRule.MaxAgeInSeconds, getRule.MaxAgeInSeconds);
                    }
                }
                finally
                {
                    // clean up
                    storageMgmtClient.StorageAccounts.Delete(rgName, accountName);
                    resourcesClient.ResourceGroups.Delete(rgName);
                }
            }
        }
Ejemplo n.º 16
0
        internal void Init()
        {
            var version = Assembly.GetExecutingAssembly().GetName().Version;
            var container = "staticfiles";

            var path = version.ToString().Replace(".", "_");

            var http = HttpContext.Current;

            #if DEBUG

            path = "debug" + "/" + path;

            #endif

            if (string.IsNullOrEmpty(_endpoint))
            {
                _endpoint = (_account.BlobEndpoint.AbsoluteUri.TrimEnd('/') + "/");
            }

            _endpoint = _endpoint + container + "/" + path.TrimEnd('/');

            var cli = _account.CreateCloudBlobClient();

            var newProperties = CurrentProperties(cli);

            //Set service to new version:
            newProperties.DefaultServiceVersion = "2013-08-15"; //"2012-02-12"; // "2011-08-18"; // null;
            cli.SetServiceProperties(newProperties);

            var addRule = true;
            if (addRule)
            {

                //Add a wide open rule to allow uploads:
                var ruleWideOpenWriter = new CorsRule()
                {
                    AllowedHeaders = { "*" },
                    AllowedOrigins = { "*" },
                    AllowedMethods =
                        CorsHttpMethods.Options |
                        CorsHttpMethods.Post |
                        CorsHttpMethods.Put |
                        CorsHttpMethods.Merge,
                    ExposedHeaders = { "*" },
                    MaxAgeInSeconds = (int)TimeSpan.FromDays(5).TotalSeconds
                };
                newProperties.Cors.CorsRules.Add(ruleWideOpenWriter);
                cli.SetServiceProperties(newProperties);
            }

            var cont = cli.GetContainerReference(container);
            cont.CreateIfNotExists();
            cont.SetPermissions(new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions { PublicAccess = Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Blob });

            var rootdir = http.Server.MapPath("~");

            foreach (var folder in _folderstoupload)
            {

                var files = new DirectoryInfo(http.Server.MapPath(folder)).EnumerateFiles("*", SearchOption.AllDirectories);

                foreach (var file in files)
                {
                    var loc = path + "/" + file.FullName.Replace(rootdir, "").Replace("\\", "/");

                    var blob = cont.GetBlockBlobReference(loc);
                    blob.DeleteIfExists();
                    var fs = file.Open(FileMode.Open);
                    blob.UploadFromStream(fs);
                    fs.Dispose();
                    //blob.UploadFromFile(file.FullName, FileMode.Create);

                }

            }
        }
Ejemplo n.º 17
0
        internal void Init()
        {
            var version   = Assembly.GetExecutingAssembly().GetName().Version;
            var container = "staticfiles";

            var path = version.ToString().Replace(".", "_");


            var http = HttpContext.Current;

#if DEBUG
            path = "debug" + "/" + path;
#endif

            if (string.IsNullOrEmpty(_endpoint))
            {
                _endpoint = (_account.BlobEndpoint.AbsoluteUri.TrimEnd('/') + "/");
            }

            _endpoint = _endpoint + container + "/" + path.TrimEnd('/');



            var cli = _account.CreateCloudBlobClient();

            var newProperties = CurrentProperties(cli);

            //Set service to new version:
            newProperties.DefaultServiceVersion = "2013-08-15"; //"2012-02-12"; // "2011-08-18"; // null;
            cli.SetServiceProperties(newProperties);

            var addRule = true;
            if (addRule)
            {
                //Add a wide open rule to allow uploads:
                var ruleWideOpenWriter = new CorsRule()
                {
                    AllowedHeaders = { "*" },
                    AllowedOrigins = { "*" },
                    AllowedMethods =
                        CorsHttpMethods.Options |
                        CorsHttpMethods.Post |
                        CorsHttpMethods.Put |
                        CorsHttpMethods.Merge,
                    ExposedHeaders  = { "*" },
                    MaxAgeInSeconds = (int)TimeSpan.FromDays(5).TotalSeconds
                };
                newProperties.Cors.CorsRules.Add(ruleWideOpenWriter);
                cli.SetServiceProperties(newProperties);
            }

            var cont = cli.GetContainerReference(container);
            cont.CreateIfNotExists();
            cont.SetPermissions(new Microsoft.WindowsAzure.Storage.Blob.BlobContainerPermissions {
                PublicAccess = Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Blob
            });

            var rootdir = http.Server.MapPath("~");

            foreach (var folder in _folderstoupload)
            {
                var files = new DirectoryInfo(http.Server.MapPath(folder)).EnumerateFiles("*", SearchOption.AllDirectories);

                foreach (var file in files)
                {
                    var loc = path + "/" + file.FullName.Replace(rootdir, "").Replace("\\", "/");

                    var blob = cont.GetBlockBlobReference(loc);
                    blob.DeleteIfExists();
                    var fs = file.Open(FileMode.Open);
                    blob.UploadFromStream(fs);
                    fs.Dispose();
                    //blob.UploadFromFile(file.FullName, FileMode.Create);
                }
            }
        }