public void CreateContainer_ValidArgumentsWithNoPublicAccess_CreatesContainerWithNoPublicAccess()
{
var containerName = GenerateSampleContainerName();
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.CreateContainer(containerName, ContainerAccessType.None);
AssertContainerAccess(containerName, Microsoft.WindowsAzure.Storage.Blob.BlobContainerPublicAccessType.Off);
}
public void CreateContainer_ValidArguments_CreatesContainerWithSpecificName()
{
var containerName = GenerateSampleContainerName();
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.CreateContainer(containerName, ContainerAccessType.None);
AssertContainerExists(containerName);
}
public void CreateContainer_AlreadyExists_ThrowsContainerAlreadyExistsException()
{
var containerName = GenerateSampleContainerName();
CreateContainer(containerName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.CreateContainer(containerName, ContainerAccessType.None);
// expects exception
}
public void CopyBlob_EmptyContainerNameGiven_ThrowsArgumentNullException()
{
var blobName = _util.GenerateSampleBlobName(_runId);
var fakeUri = "https://foo.foo.foo/";
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.CopyBlob("", blobName, fakeUri);
// throws exception
}
public void CopyBlob_RequiredArgsOnly_BeginsCopyOperation()
{
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blobUri = _util.CreateBlockBlob(containerName, blobName).Uri;
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.CopyBlob(containerName, blobName, blobUri.ToString());
_util.AssertBlobCopyOperationInProgressOrSuccessful(containerName, blobName);
}
private TestScenario Scenario(BlobServiceClient client) => new TestScenario(this, client);
public AzureBlobServiceClient(string storageAccountConnectionString)
{
_blobServiceClient = new BlobServiceClient(storageAccountConnectionString);
}
public async void LeaseBlobRenewAsync_LeasedBlob_RenewsActiveLease()
{
var minimumWaitTime = TimeSpan.FromSeconds(15);
var halfOfMinimum = minimumWaitTime.Subtract(TimeSpan.FromSeconds(minimumWaitTime.TotalSeconds * 0.5));
var threeQuartersOfMinimum = minimumWaitTime.Subtract(TimeSpan.FromSeconds(minimumWaitTime.TotalSeconds * 0.75));
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var leaseId = _util.LeaseBlob(containerName, blobName, TimeSpan.FromSeconds(15));
Thread.Sleep(halfOfMinimum);
await client.LeaseBlobRenewAsync(containerName, blobName, leaseId);
Thread.Sleep(threeQuartersOfMinimum); // wait again... if it didn't renew, by now it would be expired
_util.AssertBlobIsLeased(containerName, blobName, leaseId);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddApplicationInsightsTelemetry();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApi(options =>
{
Configuration.Bind("AzureAdB2C", options);
options.TokenValidationParameters.NameClaimType = "name";
},
options => { Configuration.Bind("AzureAdB2C", options); });
services.AddControllers().AddJsonOptions(opts =>
{
opts.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
}).AddNewtonsoftJson();
services.AddAuthorization();
services.AddSwaggerGen(c =>
{
c.ResolveConflictingActions(apiDescriptions => apiDescriptions.FirstOrDefault());
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "StarWars5e.Api", Version = "v1"
});
var securitySchema = new OpenApiSecurityScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.Http,
Scheme = "bearer",
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
};
c.AddSecurityDefinition("Bearer", securitySchema);
var securityRequirement = new OpenApiSecurityRequirement
{
{ securitySchema, new[] { "Bearer" } }
};
c.AddSecurityRequirement(securityRequirement);
});
services.AddCors(options =>
{
options.AddDefaultPolicy(
builder =>
{
builder.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod();
});
});
var tableStorage = new AzureTableStorage(Configuration["StorageAccountConnectionString"]);
var cloudStorageAccount = CloudStorageAccount.Parse(Configuration["StorageAccountConnectionString"]);
var cloudTableClient = cloudStorageAccount.CreateCloudTableClient();
var cloudBlobClient = new BlobServiceClient(Configuration["StorageAccountConnectionString"]);
var searchIndexClient = new SearchIndexClient(new Uri("https://sw5esearch.search.windows.net"), new AzureKeyCredential(Configuration["SearchKey"]));
var searchClient = new SearchClient(new Uri("https://sw5esearch.search.windows.net"), "searchterms-index", new AzureKeyCredential(Configuration["SearchKey"]));
services.AddSingleton <IAzureTableStorage>(tableStorage);
services.Scan(scan => scan
.FromAssemblies(typeof(Program).GetTypeInfo().Assembly)
.AddClasses(true)
.AsImplementedInterfaces()
.WithSingletonLifetime()
);
services.AddSingleton(cloudBlobClient);
services.AddSingleton(cloudTableClient);
services.AddSingleton(searchIndexClient);
services.AddSingleton(searchClient);
}
public AnswerImagesController(AnswerImageDataContext context, BlobServiceClient blobServiceClient)
{
_context = context;
_blobServiceClient = blobServiceClient;
}
public async void LeaseBlobChangeAsync_LeasedBlobToNewLeaseId_ChangesToMatchNewLeaseId()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var leaseId = _util.LeaseBlob(containerName, blobName);
var expectedLeaseId = Guid.NewGuid().ToString();
var response = await client.LeaseBlobChangeAsync(containerName, blobName, leaseId, expectedLeaseId);
Assert.AreEqual(expectedLeaseId, response.LeaseId);
_util.AssertBlobIsLeased(containerName, blobName, expectedLeaseId);
}
public ContainerWrapper(string storageAccountName, string sharedAccessSignatureKey)
{
ConnectionString = $"BlobEndpoint=https://{storageAccountName}.blob.core.windows.net/;SharedAccessSignature={sharedAccessSignatureKey}";
BlobServiceClient = new BlobServiceClient(ConnectionString);
RefreshContainerDetails();
}
public async void LeaseBlobBreakAsync_NonLeasedBlob_ThrowsLeaseNotPresentException()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
await client.LeaseBlobBreakAsync(containerName, blobName, FakeLeaseId, 0);
// expects exception
}
public async void LeaseBlobBreakAsync_LeasedBlobWithLongBreakPeriod_SetLeaseToBreaking()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var leaseId = _util.LeaseBlob(containerName, blobName);
await client.LeaseBlobBreakAsync(containerName, blobName, leaseId, 60);
var leaseState = _util.GetBlobLeaseState(containerName, blobName);
Assert.AreEqual(Microsoft.WindowsAzure.Storage.Blob.LeaseState.Breaking, leaseState);
}
public void LeaseBlobBreak_LeasedBlob_BreaksLease()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var leaseId = _util.LeaseBlob(containerName, blobName);
client.LeaseBlobBreak(containerName, blobName, leaseId, 0);
var leaseState = _util.GetBlobLeaseState(containerName, blobName);
Assert.AreEqual(Microsoft.WindowsAzure.Storage.Blob.LeaseState.Broken, leaseState);
}
public void LeaseBlobRelease_NonLeasedBlob_ThrowsLeaseIdMismatchException()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
client.LeaseBlobRelease(containerName, blobName, FakeLeaseId);
// expects exception
}
public async void LeaseBlobReleaseAsync_LeasedBlob_ReleasesLease()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var leaseId = _util.LeaseBlob(containerName, blobName);
await client.LeaseBlobReleaseAsync(containerName, blobName, leaseId);
_util.AssertBlobIsNotLeased(containerName, blobName);
}
public async void LeaseBlobChangeAsync_NonexistentBlob_ThrowsBlobNotFoundException()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var expectedLeaseId = Guid.NewGuid().ToString();
await client.LeaseBlobChangeAsync(containerName, blobName, FakeLeaseId, expectedLeaseId);
// expects exception
}
public void LeaseBlobChange_NonLeasedBlob_ThrowsLeaseNotPresentException()
{
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var expectedLeaseId = Guid.NewGuid().ToString();
client.LeaseBlobChange(containerName, blobName, FakeLeaseId, expectedLeaseId);
// expects exception
}
static BlobHelper()
{
// connect to Azure Storage
BlobServiceClient = new BlobServiceClient(Environment.GetEnvironmentVariable("BlobConnectionString"));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <ILocalizationProvider, StorageLocalizationProvider>();
services.AddTextLocalization(options =>
{
options.ReturnOnlyKeyIfNotFound = !_environment.IsDevelopment();
options.FallBackNeutralCulture = !_environment.IsDevelopment();
}).Configure <RequestLocalizationOptions>(options =>
{
options.DefaultRequestCulture = new RequestCulture(Settings.SupportedCultures[0]);
options.AddSupportedCultures(Settings.SupportedCultures);
options.AddSupportedUICultures(Settings.SupportedCultures);
});
services.AddScoped <LazyAssemblyLoader>();
var dataProtectionBuilder = services.AddDataProtection().SetApplicationName(projectName);
services.RegisterStorage(Configuration);
services.Configure <ApiBehaviorOptions>(options => { options.SuppressModelStateInvalidFilter = true; });
services.AddIdentity <ApplicationUser, ApplicationRole>()
.AddRoles <ApplicationRole>()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders()
.AddErrorDescriber <LocalizedIdentityErrorDescriber>();
services.AddScoped <IUserClaimsPrincipalFactory <ApplicationUser>,
AdditionalUserClaimsPrincipalFactory>();
var authAuthority = Configuration[$"{projectName}:IS4ApplicationUrl"].TrimEnd('/');
// Adds IdentityServer https://identityserver4.readthedocs.io/en/latest/reference/options.html
var identityServerBuilder = services.AddIdentityServer(options =>
{
options.IssuerUri = authAuthority;
options.Events.RaiseErrorEvents = true;
options.Events.RaiseInformationEvents = true;
options.Events.RaiseFailureEvents = true;
options.Events.RaiseSuccessEvents = true;
options.UserInteraction.ErrorUrl = "/identityserver/error";
})
.AddIdentityServerStores(Configuration)
.AddAspNetIdentity <ApplicationUser>(); //https://identityserver4.readthedocs.io/en/latest/reference/aspnet_identity.html
X509Certificate2 cert = null;
var keysLocalFolder = Path.Combine(_environment.ContentRootPath, "Keys");
if (_environment.IsDevelopment())
{
// The AddDeveloperSigningCredential extension creates temporary key material tempkey.jwk for signing tokens.
// This might be useful to get started, but needs to be replaced by some persistent key material for production scenarios.
// See http://docs.identityserver.io/en/release/topics/crypto.html#refcrypto for more information.
// https://stackoverflow.com/questions/42351274/identityserver4-hosting-in-iis
identityServerBuilder.AddDeveloperSigningCredential();
dataProtectionBuilder.PersistKeysToFileSystem(new DirectoryInfo(keysLocalFolder));
}
else
{
// Running on Azure Web App service - read the setup doc at blazor-boilerplate.readthedocs.io
// appsettings.json parameters used:
// "RunsOnAzure": true,
// "RunningAsAppService": true,
// "RunningAsDocker": false, // not implemented yet
// "AzureKeyVault": {
// "UsingKeyVault": true,
// "UseManagedAppIdentity": true,
// "AppKey": "", // not implemented yet.
// "AppSecret": "",
// "KeyVaultURI": "https://YOURVAULTNAMEHERE.vault.azure.net/",
// "CertificateIdentifier": "https://YOURVAULTNAMEHERE.vault.azure.net/certificates/BBAUTH/<HEX_VERSION_STRING_HERE>",
// "CertificateName": "BBAUTH",
// "StorageAccountBlobBaseUrl": "https://<YOUR_STORAGE_ACCOUNT_NAME_HERE>.blob.core.windows.net",
// "ContainerName": "blazor-boilerplate-keys",
// "KeysBlobName": "keys.xml"
if (Convert.ToBoolean(Configuration["HostingOnAzure:RunsOnAzure"]) == true)
{
if (Convert.ToBoolean(Configuration["HostingOnAzure:AzureKeyVault:UsingKeyVault"]) == true)
{
if (Convert.ToBoolean(Configuration["HostingOnAzure:AzurekeyVault:UseManagedAppIdentity"]) == true)
{
//https://docs.microsoft.com/en-us/aspnet/core/security/data-protection/configuration/overview
// In production environment we have already configured Managed Identity (blazor-boilerplate) using Azure Portal for our app to access Key Vault and Blob Storage.
// Set up TokenCredential options for production and development environments
bool isDeployed = !_environment.IsDevelopment();
var credentialOptions = new DefaultAzureCredentialOptions
{
ExcludeEnvironmentCredential = isDeployed,
ExcludeManagedIdentityCredential = false, // we only use this one in production
ExcludeSharedTokenCacheCredential = isDeployed,
ExcludeVisualStudioCredential = isDeployed,
ExcludeVisualStudioCodeCredential = isDeployed,
ExcludeAzureCliCredential = isDeployed,
ExcludeInteractiveBrowserCredential = isDeployed,
};
// In development environment DefaultAzureCredential() will use the shared token credential from the IDE. In Visual Studio this is under Options - Azure Service Authentication.
if (_environment.IsDevelopment())
{
// credentialOptions.SharedTokenCacheUsername = "******"; // specify user name to use if more than one Azure username is configured in IDE.
// var defaultTenantId = "?????-????-????-????-????????"; // specify AAD tenant to authenticate against (from Azure Portal - AAD - Tenant ID)
// credentialOptions.SharedTokenCacheTenantId = defaultTenantId;
// credentialOptions.VisualStudioCodeTenantId = defaultTenantId;
// credentialOptions.VisualStudioTenantId = defaultTenantId;
}
TokenCredential tokenCredential = new DefaultAzureCredential(credentialOptions);
// The Azure Storage Container (blazor-boilerplate-keys) Access Control must grant blazor-boilerplate the following roles:
// - Storage Blob Data Contributor
var blobServiceClient = new BlobServiceClient(
new Uri(Configuration["HostingOnAzure:AzureKeyVault:StorageAccountBlobBaseUrl"]),
tokenCredential);
BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient(Configuration["HostingOnAzure:AzureKeyVault:ContainerName"]);
BlobClient blobClient = blobContainerClient.GetBlobClient(Configuration["HostingOnAzure:AzureKeyVault:KeysBlobName"]);
var certificateIdentifier = Configuration["HostingOnAzure:AzureKeyVault:CertificateIdentifier"];
dataProtectionBuilder.PersistKeysToAzureBlobStorage(blobClient);
// 1. Remove the call to ProtectKeysWithAzureKeyVault below for the first run to create the keys.xml blob in place.
// 2. Add the call to ProtectKeysWithAzureKeyVault for subsequent runs.so that keys.xml gets created - see the setup doc for more information
dataProtectionBuilder.ProtectKeysWithAzureKeyVault(new Uri(certificateIdentifier), tokenCredential);
// Azure Key Vault Access Policy must grant the following permissions to the blazor-boilerplate app:
// - Secret Permissions: Get
// - Certificate Permissions: Get
// Retrieve the certificate and extract the secret so that we can build the new X509 certificate for later use by Identity Server
var certificateClient = new CertificateClient(vaultUri: new Uri(Configuration["HostingOnAzure:AzureKeyVault:KeyVaultUri"]), credential: new DefaultAzureCredential());
var secretClient = new SecretClient(vaultUri: new Uri(Configuration["HostingOnAzure:AzureKeyVault:KeyVaultUri"]), credential: new DefaultAzureCredential());
KeyVaultCertificateWithPolicy certificateWithPolicy = certificateClient.GetCertificateAsync(Configuration["HostingOnAzure:AzureKeyVault:CertificateName"]).GetAwaiter().GetResult(); // retrieves latest version of certificate
KeyVaultSecretIdentifier secretIdentifier = new KeyVaultSecretIdentifier(certificateWithPolicy.SecretId);
KeyVaultSecret secret = secretClient.GetSecretAsync(secretIdentifier.Name, secretIdentifier.Version).GetAwaiter().GetResult();
byte[] privateKeyBytes = Convert.FromBase64String(secret.Value);
cert = new X509Certificate2(privateKeyBytes, (string)null, X509KeyStorageFlags.MachineKeySet);
}
}
else // if app id and app secret are used
{
throw new NotImplementedException();
}
}
else
{
dataProtectionBuilder.PersistKeysToFileSystem(new DirectoryInfo(keysLocalFolder));
}
//TODO this implementation does not consider certificate expiration
if (Convert.ToBoolean(Configuration[$"{projectName}:UseLocalCertStore"]) == true)
{
var certificateThumbprint = Configuration[$"{projectName}:CertificateThumbprint"];
var storeLocation = StoreLocation.LocalMachine;
dynamic storeName = "WebHosting";
if (OperatingSystem.IsLinux())
{
storeLocation = StoreLocation.CurrentUser;
storeName = StoreName.My;
}
using X509Store store = new(storeName, storeLocation);
store.Open(OpenFlags.ReadOnly);
var certs = store.Certificates.Find(X509FindType.FindByThumbprint, certificateThumbprint, false);
if (certs.Count > 0)
{
cert = certs[0];
}
else
{
var certPath = Path.Combine(_environment.ContentRootPath, "AuthSample.pfx");
if (File.Exists(certPath))
{
string certificatePassword = Configuration[$"{projectName}:CertificatePassword"] ?? "Admin123";
cert = new X509Certificate2(certPath, certificatePassword,
X509KeyStorageFlags.MachineKeySet |
X509KeyStorageFlags.PersistKeySet |
X509KeyStorageFlags.Exportable);
}
}
store.Close();
}
// pass the resulting certificate to Identity Server
if (cert != null)
{
identityServerBuilder.AddSigningCredential(cert);
Log.Logger.Information($"Added certificate {cert.Subject} to Identity Server");
}
else if (OperatingSystem.IsWindows())
{
Log.Logger.Debug("Trying to use WebHosting Certificate for Identity Server");
identityServerBuilder.AddWebHostingCertificate();
}
else
{
throw new Exception("Missing Certificate for Identity Server");
}
}
var authBuilder = services.AddAuthentication(options =>
{
options.DefaultScheme = IdentityServerAuthenticationDefaults.AuthenticationScheme;
})
.AddIdentityServerAuthentication(options =>
{
options.Authority = authAuthority;
options.SupportedTokens = SupportedTokens.Jwt;
options.RequireHttpsMetadata = _environment.IsProduction();
options.ApiName = IdentityServerConfig.LocalApiName;
options.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
var accessToken = context.Request.Query["access_token"];
// If the request is for our hub...
var path = context.HttpContext.Request.Path;
if (!string.IsNullOrEmpty(accessToken) &&
(path.StartsWithSegments("/chathub")))
{
// Read the token out of the query string
context.Token = accessToken;
}
return(Task.CompletedTask);
}
};
});
#region ExternalAuthProviders
//https://github.com/dotnet/aspnetcore/blob/master/src/Security/Authentication/samples/SocialSample/Startup.cs
//https://docs.microsoft.com/en-us/aspnet/core/security/authentication/social/google-logins
if (Convert.ToBoolean(Configuration["ExternalAuthProviders:Google:Enabled"] ?? "false"))
{
authBuilder.AddGoogle(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.ClientId = Configuration["ExternalAuthProviders:Google:ClientId"];
options.ClientSecret = Configuration["ExternalAuthProviders:Google:ClientSecret"];
options.AuthorizationEndpoint += "?prompt=consent"; // Hack so we always get a refresh token, it only comes on the first authorization response
options.AccessType = "offline";
options.SaveTokens = true;
options.Events = new OAuthEvents()
{
OnRemoteFailure = HandleOnRemoteFailure
};
options.ClaimActions.MapJsonSubKey("urn:google:image", "image", "url");
options.ClaimActions.Remove(ClaimTypes.GivenName);
});
}
if (Convert.ToBoolean(Configuration["ExternalAuthProviders:Facebook:Enabled"] ?? "false"))
{
// You must first create an app with Facebook and add its ID and Secret to your user-secrets.
// https://developers.facebook.com/apps/
// https://developers.facebook.com/docs/facebook-login/manually-build-a-login-flow#login
authBuilder.AddFacebook(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.AppId = Configuration["ExternalAuthProviders:Facebook:AppId"];
options.AppSecret = Configuration["ExternalAuthProviders:Facebook:AppSecret"];
options.Scope.Add("email");
options.Fields.Add("name");
options.Fields.Add("email");
options.SaveTokens = true;
options.Events = new OAuthEvents()
{
OnRemoteFailure = HandleOnRemoteFailure
};
});
}
if (Convert.ToBoolean(Configuration["ExternalAuthProviders:Twitter:Enabled"] ?? "false"))
{
// You must first create an app with Twitter and add its key and Secret to your user-secrets.
// https://apps.twitter.com/
// https://developer.twitter.com/en/docs/basics/authentication/api-reference/access_token
authBuilder.AddTwitter(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.ConsumerKey = Configuration["ExternalAuthProviders:Twitter:ConsumerKey"];
options.ConsumerSecret = Configuration["ExternalAuthProviders:Twitter:ConsumerSecret"];
// http://stackoverflow.com/questions/22627083/can-we-get-email-id-from-twitter-oauth-api/32852370#32852370
// http://stackoverflow.com/questions/36330675/get-users-email-from-twitter-api-for-external-login-authentication-asp-net-mvc?lq=1
options.RetrieveUserDetails = true;
options.SaveTokens = true;
options.ClaimActions.MapJsonKey("urn:twitter:profilepicture", "profile_image_url", ClaimTypes.Uri);
options.Events = new TwitterEvents()
{
OnRemoteFailure = HandleOnRemoteFailure
};
});
}
//https://github.com/xamarin/Essentials/blob/master/Samples/Sample.Server.WebAuthenticator/Startup.cs
if (Convert.ToBoolean(Configuration["ExternalAuthProviders:Apple:Enabled"] ?? "false"))
{
authBuilder.AddApple(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.ClientId = Configuration["ExternalAuthProviders:Apple:ClientId"];
options.KeyId = Configuration["ExternalAuthProviders:Apple:KeyId"];
options.TeamId = Configuration["ExternalAuthProviders:Apple:TeamId"];
options.UsePrivateKey(keyId
=> _environment.ContentRootFileProvider.GetFileInfo($"AuthKey_{keyId}.p8"));
options.SaveTokens = true;
});
}
// You must first create an app with Microsoft Account and add its ID and Secret to your user-secrets.
// https://docs.microsoft.com/en-us/azure/active-directory/develop/quickstart-register-app
if (Convert.ToBoolean(Configuration["ExternalAuthProviders:Microsoft:Enabled"] ?? "false"))
{
authBuilder.AddMicrosoftAccount(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.ClientId = Configuration["ExternalAuthProviders:Microsoft:ClientId"];
options.ClientSecret = Configuration["ExternalAuthProviders:Microsoft:ClientSecret"];
options.SaveTokens = true;
options.Scope.Add("offline_access");
options.Events = new OAuthEvents()
{
OnRemoteFailure = HandleOnRemoteFailure
};
});
}
#endregion
#region Authorization
//Add Policies / Claims / Authorization - https://identityserver4.readthedocs.io/en/latest/topics/add_apis.html#advanced
services.AddScoped <EntityPermissions>();
services.AddSingleton <IAuthorizationPolicyProvider, AuthorizationPolicyProvider>();
services.AddTransient <IAuthorizationHandler, DomainRequirementHandler>();
services.AddTransient <IAuthorizationHandler, PermissionRequirementHandler>();
#endregion
services.Configure <IdentityOptions>(options =>
{
// Password settings
options.Password.RequireDigit = RequireDigit;
options.Password.RequiredLength = RequiredLength;
options.Password.RequireNonAlphanumeric = RequireNonAlphanumeric;
options.Password.RequireUppercase = RequireUppercase;
options.Password.RequireLowercase = RequireLowercase;
//options.Password.RequiredUniqueChars = 6;
// Lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Lockout.MaxFailedAccessAttempts = 10;
options.Lockout.AllowedForNewUsers = true;
// Require Confirmed Email User settings
if (Convert.ToBoolean(Configuration[$"{projectName}:RequireConfirmedEmail"] ?? "false"))
{
options.User.RequireUniqueEmail = true;
options.SignIn.RequireConfirmedEmail = true;
}
});
#region Cookies
// cookie policy to deal with temporary browser incompatibilities
services.AddSameSiteCookiePolicy();
//https://docs.microsoft.com/en-us/aspnet/core/security/gdpr
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential
// cookies is needed for a given request.
options.CheckConsentNeeded = context => false; //consent not required
// requires using Microsoft.AspNetCore.Http;
//options.MinimumSameSitePolicy = SameSiteMode.None;
});
//services.ConfigureExternalCookie(options =>
// {
// macOS login fix
//options.Cookie.SameSite = SameSiteMode.None;
//});
services.ConfigureApplicationCookie(options =>
{
options.Cookie.IsEssential = true;
options.Cookie.HttpOnly = true;
options.Cookie.SecurePolicy = CookieSecurePolicy.SameAsRequest;
options.ExpireTimeSpan = TimeSpan.FromDays(Convert.ToDouble(Configuration[$"{projectName}:CookieExpireTimeSpanDays"] ?? "30"));
options.LoginPath = Constants.Settings.LoginPath;
//options.AccessDeniedPath = "/Identity/Account/AccessDenied";
// ReturnUrlParameter requires
//using Microsoft.AspNetCore.Authentication.Cookies;
options.ReturnUrlParameter = CookieAuthenticationDefaults.ReturnUrlParameter;
options.SlidingExpiration = true;
// Suppress redirect on API URLs in ASP.NET Core -> https://stackoverflow.com/a/56384729/54159
options.Events = new CookieAuthenticationEvents()
{
OnRedirectToAccessDenied = context =>
{
if (context.Request.Path.StartsWithSegments("/api"))
{
context.Response.StatusCode = Status403Forbidden;
}
return(Task.CompletedTask);
},
OnRedirectToLogin = context =>
{
context.Response.StatusCode = Status401Unauthorized;
return(Task.CompletedTask);
}
};
});
#endregion
services.AddMvc().AddNewtonsoftJson(opt =>
{
// Set Breeze defaults for entity serialization
var ss = JsonSerializationFns.UpdateWithDefaults(opt.SerializerSettings);
if (ss.ContractResolver is DefaultContractResolver resolver)
{
resolver.NamingStrategy = null; // remove json camelCasing; names are converted on the client.
}
if (_environment.IsDevelopment())
{
ss.Formatting = Newtonsoft.Json.Formatting.Indented; // format JSON for debugging
}
}) // Add Breeze exception filter to send errors back to the client
.AddMvcOptions(o => { o.Filters.Add(new GlobalExceptionFilter()); })
.AddViewLocalization().AddDataAnnotationsLocalization(options =>
{
options.DataAnnotationLocalizerProvider = (type, factory) =>
{
return(factory.Create(typeof(Global)));
};
}).AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining <LocalizationRecordValidator>());
services.AddServerSideBlazor().AddCircuitOptions(o =>
{
if (_environment.IsDevelopment())
{
o.DetailedErrors = true;
}
}).AddHubOptions(o =>
{
o.MaximumReceiveMessageSize = 131072;
});
services.AddSignalR();
if (_enableAPIDoc)
{
services.AddOpenApiDocument(document =>
{
document.Title = "BlazorBoilerplate API";
document.Version = typeof(Startup).GetTypeInfo().Assembly.GetName().Version.ToString();
document.AddSecurity("bearer", Enumerable.Empty <string>(), new OpenApiSecurityScheme
{
Type = OpenApiSecuritySchemeType.OAuth2,
Description = "Local Identity Server",
OpenIdConnectUrl = $"{authAuthority}/.well-known/openid-configuration", //not working
Flow = OpenApiOAuth2Flow.AccessCode,
Flows = new OpenApiOAuthFlows()
{
AuthorizationCode = new OpenApiOAuthFlow()
{
Scopes = new Dictionary <string, string>
{
{ LocalApi.ScopeName, IdentityServerConfig.LocalApiName }
},
AuthorizationUrl = $"{authAuthority}/connect/authorize",
TokenUrl = $"{authAuthority}/connect/token"
},
}
});;
document.OperationProcessors.Add(new AspNetCoreOperationSecurityScopeProcessor("bearer"));
// new OperationSecurityScopeProcessor("bearer"));
});
}
services.AddScoped <IUserSession, UserSession>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.Add(ServiceDescriptor.Scoped(typeof(ITenantSettings <>), typeof(TenantSettingsManager <>)));
services.AddTransient <IEmailFactory, EmailFactory>();
services.AddTransient <IAccountManager, AccountManager>();
services.AddTransient <IAdminManager, AdminManager>();
services.AddTransient <IEmailManager, EmailManager>();
services.AddTransient <IExternalAuthManager, ExternalAuthManager>();
#region Automapper
//Automapper to map DTO to Models https://www.c-sharpcorner.com/UploadFile/1492b1/crud-operations-using-automapper-in-mvc-application/
var automapperConfig = new MapperConfiguration(configuration =>
{
configuration.AddProfile(new MappingProfile());
});
var autoMapper = automapperConfig.CreateMapper();
services.AddSingleton(autoMapper);
#endregion
/* ServerSideBlazor */
services.AddScoped <IAccountApiClient, AccountApiClient>();
services.AddScoped <AppState>();
// setup HttpClient for server side in a client side compatible fashion ( with auth cookie )
// if (!services.Any(x => x.ServiceType == typeof(HttpClient)))
// {
services.AddScoped(s =>
{
// creating the URI helper needs to wait until the JS Runtime is initialized, so defer it.
var navigationManager = s.GetRequiredService <NavigationManager>();
var httpContextAccessor = s.GetRequiredService <IHttpContextAccessor>();
var cookies = httpContextAccessor.HttpContext.Request.Cookies;
var httpClientHandler = new HttpClientHandler()
{
UseCookies = false
};
if (_environment.IsDevelopment())
{
// Return 'true' to allow certificates that are untrusted/invalid
httpClientHandler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => { return(true); };
}
var client = new HttpClient(httpClientHandler);
if (cookies.Any())
{
var cks = new List <string>();
foreach (var cookie in cookies)
{
cks.Add($"{cookie.Key}={cookie.Value}");
}
client.DefaultRequestHeaders.Add("Cookie", string.Join(';', cks));
}
client.BaseAddress = new Uri(navigationManager.BaseUri);
return(client);
});
// }
services.AddScoped <ILocalizationApiClient, LocalizationApiClient>();
services.AddScoped <IApiClient, ApiClient>();
// Authentication providers
Log.Logger.Debug("Removing AuthenticationStateProvider...");
var serviceDescriptor = services.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(AuthenticationStateProvider));
if (serviceDescriptor != null)
{
services.Remove(serviceDescriptor);
}
Log.Logger.Debug("Adding AuthenticationStateProvider...");
services.AddScoped <AuthenticationStateProvider, IdentityAuthenticationStateProvider>();
/**********************/
services.AddModules();
if (Log.Logger.IsEnabled(Serilog.Events.LogEventLevel.Debug))
{
Log.Logger.Debug($"Total Services Registered: {services.Count}");
foreach (var service in services)
{
Log.Logger.Debug($"\n\tService: {service.ServiceType.FullName}\n\tLifetime: {service.Lifetime}\n\tInstance: {service.ImplementationType?.FullName}");
}
}
}
public async void GetBlockListAsync_CommittedAndUncommittedBlocksExistsRequestAll_GetsAllBlocksCorrectly()
{
const string dataPerBlock = "foo";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Committed);
var uncommittedBlockList = _util.CreateBlockIdList(3, PutBlockListListType.Uncommitted);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
var uncommittedBlockIds = _util.GetIdsFromBlockIdList(uncommittedBlockList);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
_util.PutBlockList(containerName, blobName, blockIds);
_util.CreateBlockList(containerName, blobName, uncommittedBlockIds, dataPerBlock);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var response = await client.GetBlockListAsync(containerName, blobName, null, GetBlockListListType.All);
Assert.Greater(response.UncommittedBlocks.Count, 0);
Assert.Greater(response.CommittedBlocks.Count, 0);
_util.AssertBlockListsAreEqual(containerName, blobName, response);
}
public BlobPersister(IAzureClientFactory <BlobServiceClient> clientFactory)
{
_client = clientFactory.CreateClient(ServiceCollectionExtensions.StorageClientName);
}
public void PutBlockList_RequiredArgsOnly_CreatesBlockBlobFromLatestBlocks()
{
const string dataPerBlock = "foo";
const string expectedData = "foofoofoo";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.PutBlockList(containerName, blobName, blockListBlockIds);
_util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
_util.AssertBlobContainsData(containerName, blobName, BlobType.BlockBlob, Encoding.Unicode.GetBytes(expectedData));
}
public virtual bool TryCreateBlobServiceClientFromConnection(string connection, out BlobServiceClient client)
{
var connectionToUse = connection ?? ConnectionStringNames.Storage;
try
{
client = _blobServiceClientProvider.Create(connectionToUse, Configuration);
return(true);
}
catch (Exception e)
{
_logger.LogDebug($"Could not create BlobServiceClient. Exception: {e}");
client = default;
return(false);
}
}
public async void PutBlockListAsync_LeasedBlobCorrectLeaseSpecified_CreatesBlockBlobFromLatestBlocks()
{
const string dataPerBlock = "foo";
const string expectedData = "foofoofoo";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
var lease = _util.LeaseBlob(containerName, blobName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
await client.PutBlockListAsync(containerName, blobName, blockListBlockIds, leaseId: lease);
_util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
_util.AssertBlobContainsData(containerName, blobName, BlobType.BlockBlob, Encoding.Unicode.GetBytes(expectedData));
}
static async Task Main(string[] args)
{
// Create a BlobServiceClient object which will be used to create a container client
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
await foreach (BlobItem blobItem in containerClient.GetBlobsAsync())
{
var blobNameSplit = blobItem.Name.Split("/");
var blobDate = DateTime.Parse(blobNameSplit[3]);
// Structure based on servername/databasename/audit_name/date/filename.xel
if (
blobNameSplit[0] == serverName &&
blobNameSplit[1] == databaseName &&
blobItem.Name.EndsWith(".xel") &&
blobDate >= startDate &&
blobDate <= endDate
)
{
Console.WriteLine("\t" + blobItem.Name);
//Assuming we meet all the filtering criteria, parse and output to log analytics
BlobClient blobClient = containerClient.GetBlobClient(blobItem.Name);
BlobDownloadInfo download = await blobClient.DownloadAsync();
string downloadFilePath = "holdinglog.xel";
using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath))
{
await download.Content.CopyToAsync(downloadFileStream);
downloadFileStream.Close();
}
List <IReadOnlyDictionary <string, object> > events = new List <IReadOnlyDictionary <string, object> >();
XEFileEventStreamer xelreader = new XEFileEventStreamer(downloadFilePath);
xelreader.ReadEventStream(
() =>
{
return(Task.CompletedTask);
},
xevent =>
{
events.Add(xevent.Fields);
return(Task.CompletedTask);
},
CancellationToken.None).Wait();
string json = JsonSerializer.Serialize(events);
var jsonBytesSize = Encoding.UTF8.GetBytes(json).Length;
if (jsonBytesSize > 30000000)
{
splitAndPost(events);
}
else
{
post(json);
}
File.Delete(downloadFilePath);
}
}
}
public void PutBlockList_LeasedBlobWithNoLeaseGiven_ThrowsLeaseIdMissingAzureException()
{
const string dataPerBlock = "foo";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
_util.LeaseBlob(containerName, blobName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.PutBlockList(containerName, blobName, blockListBlockIds);
// throws exception
}
/// <summary> /// Get a <see cref="BlobServiceClient"/>'s <see cref="HttpPipeline"/> /// for creating child clients. /// </summary> /// <param name="client">The BlobServiceClient.</param> /// <returns>The BlobServiceClient's HttpPipeline.</returns> public static new HttpPipeline GetHttpPipeline(BlobServiceClient client) => BlobServiceClient.GetHttpPipeline(client);
public async void PutBlockListAsync_LeasedBlobWithIncorrectLeaseGiven_ThrowsLeaseIdMismatchWithBlobOperationAzureException()
{
const string dataPerBlock = "foo";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
_util.LeaseBlob(containerName, blobName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
await client.PutBlockListAsync(containerName, blobName, blockListBlockIds, leaseId: GetGuidString());
// throws exception
}
public BlobStorageStorage(StorageConfiguration configuration)
{
_configuration = configuration;
_client = new BlobServiceClient(_configuration.BlobConnectionString);
}
public async void PutBlockListAsync_LeasedBlobWithInvalidLeaseGiven_ThrowsArgumentException()
{
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
await client.PutBlockListAsync(containerName, blobName, blockListBlockIds, leaseId: InvalidLeaseId);
// throws exception
}
public static async Task Run(ILogger log, Microsoft.Azure.WebJobs.ExecutionContext context)
{
var client = new GitHubClient(new ProductHeaderValue("TrackRepos"));
var basicAuth = new Credentials(Environment.GetEnvironmentVariable("GitHubToken"));
client.Credentials = basicAuth;
string storageConnectionString = Environment.GetEnvironmentVariable("AzureWebJobsStorage");
BlobServiceClient blobServiceClient = new BlobServiceClient(storageConnectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient("repos");
BlobClient blobClient = containerClient.GetBlobClient("Repos.json");
BlobDownloadInfo download = await blobClient.DownloadAsync();
List <Campaign> campaigns = JsonConvert.DeserializeObject <List <Campaign> >(new StreamReader(download.Content).ReadToEnd());
List <RepoStats> stats = new List <RepoStats>();
foreach (Campaign campaign in campaigns)
{
if (!string.IsNullOrEmpty(campaign.CampaignName) && !string.IsNullOrEmpty(campaign.OrgName))
{
foreach (Repo repo in campaign.Repos)
{
if (!string.IsNullOrEmpty(repo.RepoName))
{
var views = await client.Repository.Traffic.GetViews(campaign.OrgName, repo.RepoName, new RepositoryTrafficRequest(TrafficDayOrWeek.Day));
var clones = await client.Repository.Traffic.GetClones(campaign.OrgName, repo.RepoName, new RepositoryTrafficRequest(TrafficDayOrWeek.Day));
foreach (var item in views.Views)
{
var stat = new RepoStats($"{campaign.CampaignName}{repo.RepoName}", item.Timestamp.UtcDateTime.ToShortDateString().Replace("/", ""))
{
OrgName = campaign.OrgName,
CampaignName = campaign.CampaignName,
RepoName = repo.RepoName,
Date = item.Timestamp.UtcDateTime.ToShortDateString(),
Views = item.Count,
UniqueUsers = item.Uniques
};
var clone = clones.Clones.Where(a => a.Timestamp.UtcDateTime.ToShortDateString() == item.Timestamp.UtcDateTime.ToShortDateString()).FirstOrDefault();
if (clone != null)
{
stat.Clones = clone.Count;
stat.UniqueClones = clone.Uniques;
}
stats.Add(stat);
}
Thread.Sleep(5000);
}
}
}
}
string tableName = "RepoStats";
CloudTable table = await TableStorageHelper.CreateTableAsync(tableName);
foreach (var view in stats)
{
Console.WriteLine("Insert an Entity.");
await TableStorageHelper.InsertOrMergeEntityAsync(table, view);
}
}
public async void PutBlockListAsync_InvalidBlockId_ThrowsInvalidBlockListAzureException()
{
const string dataPerBlock = "foo";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
blockListBlockIds.Add(new BlockListBlockId
{
Id = Base64Converter.ConvertToBase64("id4"),
ListType = PutBlockListListType.Latest
});
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
await client.PutBlockListAsync(containerName, blobName, blockListBlockIds);
// Throws exception
}
public TestScenario(BlobBatchClientTests test, BlobServiceClient service)
{
_test = test;
Service = service;
}
public async void PutBlockListAsync_WithMetadata_UploadsMetadata()
{
const string dataPerBlock = "foo";
var expectedMetadata = new Dictionary<string, string>(){
{ "firstValue", "1" },
{ "secondValue", "2"}
};
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
await client.PutBlockListAsync(containerName, blobName, blockListBlockIds, metadata: expectedMetadata);
var blob = _util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
Assert.IsTrue(blob.Metadata.Any(m => m.Key == "firstValue" && m.Value == "1"), "First value is missing or incorrect");
Assert.IsTrue(blob.Metadata.Any(m => m.Key == "secondValue" && m.Value == "2"), "Second value is missing or incorrect");
}
public ContainerWriter(string connectionString, string containerName)
{
blobServiceClient = new BlobServiceClient(connectionString);
this.containerName = containerName ?? throw new ArgumentNullException(nameof(containerName));
}
private static async void StoreMessageToLocalBlobstore(ModuleClient moduleClient, Message message, string messageString)
{
string storageConnectionString = Environment.GetEnvironmentVariable("storageconnectionstring");
string storageContainername = Environment.GetEnvironmentVariable("storageContainername");
BlobServiceClient blobServiceClient = null;
BlobContainerClient Container = null;
string sourceFile = null;
try
{
blobServiceClient = new BlobServiceClient(storageConnectionString);
}catch (Exception)
{
Console.WriteLine(
"A connection string has not been defined in the system environment variables. " +
"Add a environment variable named 'storageconnectionstring' with your storage " +
"connection string as a value.");
return;
}
// Check whether the connection string can be parsed.
// We definetly should check for a valid container name. Very common error is to use upper case characters
if (storageContainername == null || storageContainername.Length == 0 /*| storageContainername.Any(char.IsUpper)*/)
{
storageContainername = "samplecontainer";
}
try
{
// Create a container called 'samplecontainer' and append a GUID value to it to make the name unique.
Container = blobServiceClient.GetBlobContainerClient(storageContainername);
await Container.CreateIfNotExistsAsync();
Console.WriteLine("Successfully created container '{storageContainername}'");
await Container.SetAccessPolicyAsync(PublicAccessType.Blob).ConfigureAwait(false);
Console.WriteLine($"Permissions set");
// Create a file in your local MyDocuments folder to upload to a blob.
string localPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string localFileName = "MessageContents_" + DateTime.UtcNow.ToString("yyyy-MM-ddTHHmmss") + ".txt";
sourceFile = Path.Combine(localPath, localFileName);
// Write text to the file.
File.WriteAllText(sourceFile, messageString);
Console.WriteLine("Uploading to Blob storage as blob '{0}'", localFileName);
// Get a reference to the blob address, then upload the file to the blob.
// Use the value of localFileName for the blob name.
BlobClient blobClient = Container.GetBlobClient(localFileName);
await blobClient.UploadAsync(sourceFile);
}
catch (Exception ex)
{
Console.WriteLine("Error returned from the service: {0}", ex.Message);
} finally
{
File.Delete(sourceFile);
}
}
public void SetUp()
{
_fixture = new AzureStorageEndToEndTests.TestFixture(TestEnvironment);
_queueServiceClient = _fixture.QueueServiceClient;
_blobServiceClient = _fixture.BlobServiceClient;
}
public BlobLeaseManager(BlobServiceClient blobServiceClient, string leaseContainerName, string leaseBlobName, ILogger logger)
{
leaseContainerClient = blobServiceClient.GetBlobContainerClient(leaseContainerName);
leaseBlobClient = leaseContainerClient.GetPageBlobClient(leaseBlobName);
this.logger = logger;
}
public AzureBlobService(BlobServiceClient blobServiceClient)
{
this.blobServiceClient = blobServiceClient;
}
static async Task Container()
{
BlobServiceClient blobServiceClient = new BlobServiceClient(storageconnstring);
BlobContainerClient containerClient = await blobServiceClient.CreateBlobContainerAsync(containerName);
}
public static IActionResult Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[AzureClient("StorageConnection")] BlobServiceClient client)
{
return(new OkObjectResult(client.GetBlobContainers().ToArray()));
}
public async void LeaseBlobRenewAsync_RecentlyLeasedBlob_RenewsLease()
{
var minimumWaitTime = TimeSpan.FromSeconds(15);
var moreThanMinimumWaitTime = minimumWaitTime.Add(TimeSpan.FromSeconds(1));
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var leaseId = _util.LeaseBlob(containerName, blobName, TimeSpan.FromSeconds(15));
Thread.Sleep(moreThanMinimumWaitTime);
await client.LeaseBlobRenewAsync(containerName, blobName, leaseId);
_util.AssertBlobIsLeased(containerName, blobName, leaseId);
}
public async Task InitializeAsync(WebJobsTestEnvironment testEnvironment)
{
RandomNameResolver nameResolver = new RandomNameResolver();
Host = new HostBuilder()
.ConfigureDefaultTestHost <BlobBindingEndToEndTests>(b =>
{
b.AddAzureStorageBlobs().AddAzureStorageQueues();
b.AddAzureStorageCoreServices();
})
.ConfigureServices(services =>
{
services.AddSingleton <INameResolver>(nameResolver);
})
.Build();
JobHost = Host.GetJobHost();
BlobServiceClient = new BlobServiceClient(testEnvironment.PrimaryStorageAccountConnectionString);
BlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(ContainerName));
Assert.False(await BlobContainer.ExistsAsync());
await BlobContainer.CreateAsync();
OutputBlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(OutputContainerName));
var pageBlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(PageBlobContainerName));
Assert.False(await pageBlobContainer.ExistsAsync());
await pageBlobContainer.CreateAsync();
var hierarchicalBlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(HierarchicalBlobContainerName));
Assert.False(await hierarchicalBlobContainer.ExistsAsync());
await hierarchicalBlobContainer.CreateAsync();
var appendBlobContainer = BlobServiceClient.GetBlobContainerClient(nameResolver.ResolveInString(AppendBlobContainerName));
Assert.False(await appendBlobContainer.ExistsAsync());
await appendBlobContainer.CreateAsync();
await Host.StartAsync();
// upload some test blobs
BlockBlobClient blob = BlobContainer.GetBlockBlobClient("blob1");
await blob.UploadTextAsync(TestData);
blob = BlobContainer.GetBlockBlobClient("blob2");
await blob.UploadTextAsync(TestData);
blob = BlobContainer.GetBlockBlobClient("blob3");
await blob.UploadTextAsync(TestData);
blob = BlobContainer.GetBlockBlobClient("file1");
await blob.UploadTextAsync(TestData);
blob = BlobContainer.GetBlockBlobClient("file2");
await blob.UploadTextAsync(TestData);
blob = BlobContainer.GetBlockBlobClient("overwrite");
await blob.UploadTextAsync(TestData);
// add a couple hierarchical blob paths
blob = hierarchicalBlobContainer.GetBlockBlobClient("sub/blob1");
await blob.UploadTextAsync(TestData);
blob = hierarchicalBlobContainer.GetBlockBlobClient("sub/blob2");
await blob.UploadTextAsync(TestData);
blob = hierarchicalBlobContainer.GetBlockBlobClient("sub/sub/blob3");
await blob.UploadTextAsync(TestData);
blob = hierarchicalBlobContainer.GetBlockBlobClient("blob4");
await blob.UploadTextAsync(TestData);
byte[] bytes = new byte[512];
byte[] testBytes = Encoding.UTF8.GetBytes(TestData);
for (int i = 0; i < testBytes.Length; i++)
{
bytes[i] = testBytes[i];
}
PageBlobClient pageBlob = pageBlobContainer.GetPageBlobClient("blob1");
await pageBlob.UploadFromByteArrayAsync(bytes, 0);
pageBlob = pageBlobContainer.GetPageBlobClient("blob2");
await pageBlob.UploadFromByteArrayAsync(bytes, 0);
AppendBlobClient appendBlob = appendBlobContainer.GetAppendBlobClient("blob1");
await appendBlob.UploadTextAsync(TestData);
appendBlob = appendBlobContainer.GetAppendBlobClient("blob2");
await appendBlob.UploadTextAsync(TestData);
appendBlob = appendBlobContainer.GetAppendBlobClient("blob3");
await appendBlob.UploadTextAsync(TestData);
}
public async void PutBlockListAsync_WithBlobContentMD5_UploadsWithSpecifiedBlobContentMD5()
{
const string dataPerBlock = "foo";
const string expectedData = "foofoofoo";
var expectedContentMD5 = Convert.ToBase64String((MD5.Create()).ComputeHash(Encoding.Unicode.GetBytes(expectedData)));
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
await client.PutBlockListAsync(containerName, blobName, blockListBlockIds, blobContentMD5: expectedContentMD5);
var blob = _util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
Assert.AreEqual(expectedContentMD5, blob.Properties.ContentMD5);
}
private static IAsyncObjectToTypeConverter <BlobBaseClient> CreateConverter(BlobServiceClient client)
{
return(new CompositeAsyncObjectToTypeConverter <BlobBaseClient>(
new BlobOutputConverter <BlobBaseClient>(new AsyncConverter <BlobBaseClient, BlobBaseClient>(new IdentityConverter <BlobBaseClient>())),
new BlobOutputConverter <string>(new StringToCloudBlobConverter(client))));
}
public void PutBlockList_WithBlobContentEncoding_UploadsWithSpecifiedBlobContentEncoding()
{
const string dataPerBlock = "foo";
const string expectedContentEncoding = "UTF32";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock, Encoding.UTF32);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
client.PutBlockList(containerName, blobName, blockListBlockIds, contentEncoding: expectedContentEncoding);
var blob = _util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
Assert.AreEqual(expectedContentEncoding, blob.Properties.ContentEncoding);
}
public AppartmentsController(BookingContext context, BlobServiceClient blobService)
{
_context = context;
_blobService = blobService;
}
public async void PutBlockListAsync_WithBlobContentLanguage_UploadsWithSpecifiedBlobContentLanguage()
{
const string dataPerBlock = "foo";
const string expectedContentLanguage = "gibberish";
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
var blockListBlockIds = _util.CreateBlockIdList(3, PutBlockListListType.Latest);
var blockIds = _util.GetIdsFromBlockIdList(blockListBlockIds);
_util.CreateBlockList(containerName, blobName, blockIds, dataPerBlock);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
await client.PutBlockListAsync(containerName, blobName, blockListBlockIds, contentLanguage: expectedContentLanguage);
var blob = _util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
Assert.AreEqual(expectedContentLanguage, blob.Properties.ContentLanguage);
}
public BlobService(string storageAccount)
{
_blobServiceClient = new BlobServiceClient(storageAccount);
}
public void PutBlockBlob_RequiredArgsOnly_UploadsBlobSuccessfully()
{
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var data = Encoding.UTF8.GetBytes("unit test content");
client.PutBlockBlob(containerName, blobName, data);
_util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
}
static async Task Main(string[] args)
{
Console.WriteLine("Azure Blob storage v12 - .NET C# Console quickstart sample\n");
// Retrieve the connection string for use with the application. The storage
// connection string is stored in an environment variable on the machine
// running the application called AZURE_STORAGE_CONNECTION_STRING. If the
// environment variable is created after the application is launched in a
// console or with Visual Studio, the shell or application needs to be closed
// and reloaded to take the environment variable into account.
string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING");
Console.WriteLine(string.Concat("connectionString:", connectionString));
// Create a BlobServiceClient object which will be used to create a container client
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
//Create a unique name for the container
string containerName = "test" + Guid.NewGuid().ToString();
// Create the container and return a container client object
BlobContainerClient containerClient = await blobServiceClient.CreateBlobContainerAsync(containerName);
// Create a local file in the ./data/ directory for uploading and downloading
string localPath = "./data/";
string fileName = "test" + Guid.NewGuid().ToString() + ".txt";
string localFilePath = Path.Combine(localPath, fileName);
// Write text to the file
File.WriteAllText(localFilePath, "Hello, World!");
// Get a reference to a blob
BlobClient blobClient = containerClient.GetBlobClient(fileName);
Console.WriteLine("Uploading to Blob storage as blob:\n\t {0}\n", blobClient.Uri);
// Open the file and upload its data
using (FileStream uploadFileStream = File.OpenRead(localFilePath)) {
await blobClient.UploadAsync(uploadFileStream, true);
uploadFileStream.Close();
};
Console.WriteLine("Listing blobs...");
// List all blobs in the container
foreach (BlobItem blobItem in containerClient.GetBlobs())
{
Console.WriteLine("\t" + blobItem.Name);
}
// Download the blob to a local file
// Append the string "DOWNLOADED" before the .txt extension
// so you can compare the files in the data directory
string downloadFilePath = localFilePath.Replace(".txt", "DOWNLOADED.txt");
Console.WriteLine("\nDownloading blob to\n\t{0}\n", downloadFilePath);
// Download the blob's contents and save it to a file
BlobDownloadInfo download = await blobClient.DownloadAsync();
using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath))
{
await download.Content.CopyToAsync(downloadFileStream);
downloadFileStream.Close();
}
// Clean up
Console.Write("Press any key to begin clean up");
Console.ReadLine();
Console.WriteLine("Deleting blob container...");
await containerClient.DeleteAsync();
Console.WriteLine("Deleting the local source and downloaded files...");
File.Delete(localFilePath);
File.Delete(downloadFilePath);
Console.WriteLine("Done");
Console.ReadLine();
}
public async void PutBlockBlobAsync_LeasedBlobWithCorrectLeaseId_UploadsBlobSuccessfully()
{
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
var correctLease = _util.LeaseBlob(containerName, blobName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var data = Encoding.UTF8.GetBytes("unit test content");
await client.PutBlockBlobAsync(containerName, blobName, data, leaseId: correctLease);
_util.AssertBlobExists(containerName, blobName, BlobType.BlockBlob);
}
public BlobService(BlobServiceClient blobServiceClient)
{
_blobServiceClient = blobServiceClient;
}
public async void PutBlockBlobAsync_LeasedBlobWithNoLeaseGiven_ThrowsLeaseIdMissingAzureException()
{
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
_util.LeaseBlob(containerName, blobName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var data = Encoding.UTF8.GetBytes("unit test content");
await client.PutBlockBlobAsync(containerName, blobName, data);
// throws exception
}
private AzureBlobLeaseProvider(AzureBlobLeaseProviderOptions options)
{
this.blobClient = options.ServiceUri != null ? new BlobServiceClient(options.ServiceUri, options.TokenCredential) : new BlobServiceClient(options.DataConnectionString);
this.options = options;
}
public void PutBlockBlob_LeasedBlobWithIncorrectLeaseGiven_ThrowsLeaseIdMismatchWithBlobOperationAzureException()
{
var containerName = _util.GenerateSampleContainerName(_runId);
var blobName = _util.GenerateSampleBlobName(_runId);
_util.CreateContainer(containerName);
_util.CreateBlockBlob(containerName, blobName);
_util.LeaseBlob(containerName, blobName);
IBlobServiceClient client = new BlobServiceClient(AccountSettings);
var data = Encoding.UTF8.GetBytes("unit test content");
client.PutBlockBlob(containerName, blobName, data, leaseId: GetGuidString());
// throws exception
}
/// <summary> /// Get a <see cref="BlobServiceClient"/>'s authentication /// <see cref="HttpPipelinePolicy"/> for creating child clients. /// </summary> /// <param name="client">The BlobServiceClient.</param> /// <returns>The BlobServiceClient's authentication policy.</returns> public static new HttpPipelinePolicy GetAuthenticationPolicy(BlobServiceClient client) => BlobServiceClient.GetAuthenticationPolicy(client);
public AzureBlobFileUploader(BlobServiceClient blobServiceClient)
{
this.blobServiceClient = blobServiceClient;
}
