public CloudBlob UploadText(string blobName, string text, string containerName, bool isPublic)
{
var container = BlobClient.GetContainerReference(containerName);
container.CreateIfNotExist();
if (isPublic)
{
var permissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Container
};
container.SetPermissions(permissions);
}
else
{
var permissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Off
};
container.SetPermissions(permissions);
}
var blob = container.GetBlockBlobReference(blobName);
blob.UploadText(text);
return blob;
}
public string Get(string blobName, string contentType)
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
string.Format("DefaultEndpointsProtocol=http;AccountName={0};AccountKey={1}",
storageAccountName, storageAccountKey));
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer blobContainer = blobClient.GetContainerReference(containerName);
blobContainer.CreateIfNotExist();
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;
containerPermissions.SharedAccessPolicies.Add("mypolicy", new SharedAccessPolicy()
{
Permissions = SharedAccessPermissions.Write | SharedAccessPermissions.Read ,
SharedAccessExpiryTime = DateTime.Now.Add(TimeSpan.FromHours(4))
});
blobContainer.SetPermissions(containerPermissions);
string sas = blobContainer.GetSharedAccessSignature(new SharedAccessPolicy(), "mypolicy");
return string.Format("{0}/{1}{2}", blobContainer.Uri, blobName, sas);
}
public void CreateIfNotExist(CloudBlobContainer cloudBlobContainer, bool isPublic = true)
{
cloudBlobContainer.CreateIfNotExist();
var permission = cloudBlobContainer.GetPermissions();
var blobContainerPermissions = new BlobContainerPermissions {PublicAccess = isPublic ? BlobContainerPublicAccessType.Container : BlobContainerPublicAccessType.Off};
cloudBlobContainer.SetPermissions(blobContainerPermissions);
}
public List<BlobFileresult> getAllBlobsUnderCourse(Guid courseId)
{
List<BlobFileresult> blobUris = new List<BlobFileresult>();
CloudBlobContainer container = blobClient.GetContainerReference(courseId.ToString());
if (container.CreateIfNotExist())
{
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(containerPermissions);
}
// Loop over items within the container and output the length and URI.
foreach (IListBlobItem item in container.ListBlobs())
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
int lastIndexOfSpecialChar = blob.Name.LastIndexOf(specialChar);
int lastIndexOfExtensionChar = blob.Name.LastIndexOf(extensionChar);
string blobNameWithoutOwner = blob.Name.Substring(0,lastIndexOfSpecialChar);
string ownerName = blob.Name.Substring(lastIndexOfSpecialChar + 1, lastIndexOfExtensionChar - lastIndexOfSpecialChar - 1);
blobUris.Add(new BlobFileresult(blobNameWithoutOwner, blob.Uri, ownerName, blob.Properties.LastModifiedUtc));
}
}
return blobUris;
}
public void Create(bool publiccontainer)
{
// Create if it doesn't exist
Container.CreateIfNotExist();
var perm = new BlobContainerPermissions();
perm.PublicAccess = publiccontainer ? BlobContainerPublicAccessType.Blob : BlobContainerPublicAccessType.Off;
Container.SetPermissions(perm);
}
/// <summary>
/// Creates the bucket.
/// </summary>
/// <param name="name">The name.</param>
public void CreateBucket(string name)
{
CloudBlobContainer container = GetProvider(name);
BlobContainerPermissions permissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Container
};
container.CreateIfNotExist();
container.SetPermissions(permissions);
}
/// <summary>
/// Init the container with the specified name.
/// The container is initialized with Blog Public Access permissions
/// </summary>
/// <param name="containerName">Name of container to INIT</param>
public static void InitContainer(string containerName)
{
var _blobClient = Account.CreateCloudBlobClient();
var _blobContainer = _blobClient.GetContainerReference(containerName);
var permissions = new BlobContainerPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Blob;
_blobContainer.CreateIfNotExist();
_blobContainer.SetPermissions(permissions);
}
/// <summary>
/// deletes the contents of a logging blob.
/// </summary>
/// <param name="blobName"></param>
public static void clearLogBlob(string blobName)
{
string baseUri = "";
CloudBlobContainer blobContainer = initContainer(AccountInfo.LogContainer, ref baseUri);
blobContainer.CreateIfNotExist();
var perms = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Container // Blob (see files if you know the name) or Container (enumerate like a directory)
};
blobContainer.SetPermissions(perms); // This line makes the blob public so it is available from a web browser (no magic needed to read it)
CloudBlob blob = blobContainer.GetBlobReference(blobName);
blob.DeleteIfExists();
}
public ActionResult Delete(string url)
{
var blobContainer = this.blobClient.GetContainerReference(ConfigReader.GetConfigValue("TileImagesContainer"));
if (blobContainer.CreateIfNotExist())
{
var permissions = new BlobContainerPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
blobContainer.SetPermissions(permissions);
}
var blob = blobContainer.GetBlobReference(url);
blob.DeleteIfExists();
return RedirectToAction("Index");
}
static void CreateContainer()
{
//get blob container
account = CloudStorageAccount.FromConfigurationSetting("BlobConnectionString");
client = account.CreateCloudBlobClient();
container = client.GetContainerReference("userphotos");
container.CreateIfNotExist();
BlobContainerPermissions permissions = new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
container.SetPermissions(permissions);
}
/// <summary>
/// Creates container with given name and permissions
/// </summary>
/// <param name="containerName"></param>
/// <param name="containerPermissions"></param>
/// <returns></returns>
public bool CreateContainer(string containerName, BlobContainerPermissions containerPermissions)
{
CloudBlobContainer container = blobManager.GetContainerReference(containerName);
try
{
container.CreateIfNotExist();
container.SetPermissions(containerPermissions);
return true;
}
catch (Exception)
{
}
return false;
}
public static void log(string message = "")
{
Settings settings = new Settings();
string loggingstring = settings.Get("logging");
bool isLoggingEnabled = (loggingstring.ToLower().Trim() != "true") ? false : true;
if (isLoggingEnabled) {
DiscountBlobContainer logblobs = new DiscountBlobContainer();
logblobs = BlobManagement.GetContainer("logs");
BlobContainerPermissions perms = new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob };
logblobs.Container.SetPermissions(perms);
CloudBlob blob = logblobs.Container.GetBlobReference("log-" + String.Format("{0:MM-dd-yyyy}", DateTime.Now) + ".txt");
string blobtext = "";
try {
blobtext = blob.DownloadText();
} catch { };
blob.UploadText(blobtext + String.Format("{0:M-d-yyyy HH:mm:ss.fff: }", DateTime.Now) + message + Environment.NewLine);
}
}
public string AddToBucket(string bucketName, string path)
{
var blobContainer = blobStorage.GetContainerReference(bucketName);
blobContainer.CreateIfNotExist();
var containerPermissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
blobContainer.SetPermissions(containerPermissions);
var blobReference = blobContainer.GetBlobReference(Path.GetFileName(path));
blobReference.Properties.ContentType = "image/jpeg";
blobReference.UploadFile(path);
return blobReference.Uri.ToString();
//var blob = _cloudBlobContainer.GetBlobReference(blobStorage.GetContainerReference(bucketName));
//blob.UploadByteArray(data);
}
public void uploadToBlob(Guid courseId, string fileName,string owner, FileStream fileStream)
{
// Retrieve a reference to a container.
CloudBlobContainer container = blobClient.GetContainerReference(courseId.ToString());
// Create the container if it doesn't already exist.
if (container.CreateIfNotExist())
{
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(containerPermissions);
}
// create name of blob
string blobName = new StringBuilder(fileName + specialChar + owner + Path.GetExtension(fileStream.Name)).ToString();
// retrieve reference to the blob
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
blob.UploadFromStream(fileStream);
}
public static string GenerateSAS(string containerName, string blobUri)
{
string res = null;
if ((string.IsNullOrEmpty(containerName)) || (string.IsNullOrEmpty(blobUri)))
throw new ArgumentException("Both container name and blob Uri must containt valid values");
var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
var blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(containerName);
CloudBlob blob = blobClient.GetBlobReference(blobUri);
container.CreateIfNotExist();
try
{
BlobContainerPermissions permissions = new BlobContainerPermissions();
// The container itself doesn't allow public access.
permissions.PublicAccess = BlobContainerPublicAccessType.Off;
// The container itself doesn't allow SAS access.
SharedAccessPolicy containerPolicy = new SharedAccessPolicy() { Permissions = SharedAccessPermissions.None };
permissions.SharedAccessPolicies.Clear();
permissions.SharedAccessPolicies.Add("SASPolicy", containerPolicy);
container.SetPermissions(permissions);
// Generate an SAS for the blob.
SharedAccessPolicy blobPolicy = new SharedAccessPolicy()
{
Permissions = SharedAccessPermissions.Read,
SharedAccessExpiryTime = DateTime.UtcNow.AddDays(1d)
};
res = blob.GetSharedAccessSignature(blobPolicy, "SASPolicy");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return res;
}
/// <summary>
/// Configures Azure account and container
/// </summary>
/// <param name="bloburl">string with url to the blob</param>
/// <param name="connectionString">Azure blob connection string</param>
public void ConfigureAzure(string bloburl, string connectionString)
{
// Azure preparations
DestinationBlobUrl = bloburl;
// Set storage account
cloudStorageAccount = CloudStorageAccount.Parse(connectionString);
// Initialize client
blobClient = new Microsoft.WindowsAzure.StorageClient.CloudBlobClient(cloudStorageAccount.BlobEndpoint,
cloudStorageAccount.Credentials);
// Get the container reference.
blobContainer = blobClient.GetContainerReference(bloburl);
// Create the container if it does not exist.
blobContainer.CreateIfNotExist();
// Set permissions on the container.
containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;
blobContainer.SetPermissions(containerPermissions);
}
public string StoreDeploymentPackageInBlob(string csPkgFileLocation,
string blobUrl,
string storageAccountName,
string storageAccountKey)
{
string fileName;
bool containerCreated = false;
StorageCredentials storageCredentails;
CloudBlobClient blobClient;
CloudBlobContainer packageContainer;
CloudBlob deploymentBlob;
storageCredentails = new StorageCredentialsAccountAndKey(storageAccountName, storageAccountKey);
blobClient = new CloudBlobClient(blobUrl, storageCredentails);
packageContainer = blobClient.GetContainerReference(_cspkgBlobContainerName);
try { containerCreated = packageContainer.CreateIfNotExist(); }
catch { };
if (containerCreated == true)
{
BlobContainerPermissions permissions = new BlobContainerPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
packageContainer.SetPermissions(permissions);
}
//Upload a file.
Console.WriteLine("Uploading Deployment package - start");
fileName = Path.GetFileName(csPkgFileLocation);
deploymentBlob = packageContainer.GetBlobReference(fileName);
using (FileStream fs = new FileStream(csPkgFileLocation, FileMode.Open))
{
deploymentBlob.UploadFromStream(fs);
}
Console.WriteLine("Uploading Deployment package - end");
return String.Format(deploymentBlob.Uri.ToString());
}
public string CreateContainer(string containerName, bool createIfNotExists, bool isPublic)
{
// Authenticate.
var userId = this.UserId;
this.requestValidator.OnValidateRequest(userId, containerName, true);
try
{
var container = this.cloudBlobClient.GetContainerReference(containerName.ToLowerInvariant());
if (createIfNotExists)
{
container.CreateIfNotExist();
}
else
{
container.Create();
}
var publicBlobContainerPrivilege = string.Format(CultureInfo.InvariantCulture, "{0}{1}", containerName, PrivilegeConstants.PublicBlobContainerPrivilegeSuffix);
if (isPublic)
{
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(containerPermissions);
}
var accessBlobContainerPrivilege = string.Format(CultureInfo.InvariantCulture, "{0}{1}", containerName, PrivilegeConstants.BlobContainerPrivilegeSuffix);
this.userPrivilegesRepository.AddPrivilegeToUser(userId, accessBlobContainerPrivilege);
return "Success";
}
catch (Exception exception)
{
throw new WebFaultException<string>(exception.Message, HttpStatusCode.InternalServerError);
}
}
public BlobContainer(string connectionString, string containerName)
{
// Connect, if not already connected
CloudBlobClient client;
if (!clients.TryGetValue(connectionString, out client)) {
// Connect
client = CloudStorageAccount.Parse(connectionString).CreateCloudBlobClient();
// Store for next time
clients[connectionString] = client;
}
// Get container
Container = client.GetContainerReference(containerName);
// Create if it doesn't exist
Container.CreateIfNotExist();
// Set access public
var perm = new BlobContainerPermissions();
perm.PublicAccess = BlobContainerPublicAccessType.Blob;
Container.SetPermissions(perm);
}
private static dynamic initAzureConfig()
{
var _timeout = 45;
var account = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=eagleraydev;AccountKey=UFc4ZR15pEDv1wlXJv43j+zLeJ1FMUYfpfQQBTFO5O9hDPWskLxFk16VKIKlSb0mm+jZVgdaHmsGD9Qa4krlEg==");
var _containerName = "test";
_containerName = _containerName.ToLowerInvariant(); // Azure requires container names to be lower case.
var _blobs = account.CreateCloudBlobClient();
// Init Container
var container = _blobs.GetContainerReference(_containerName);
var _containerPermissions = new BlobContainerPermissions();
_containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.CreateIfNotExist();
container.SetPermissions(_containerPermissions);
var sas = container.GetSharedAccessSignature(new SharedAccessPolicy()
{
// Read required to get existing metadata
Permissions = SharedAccessPermissions.Read | SharedAccessPermissions.Write,
SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromMinutes(_timeout)
});
// Generate ServiceUri
var service = (new UriBuilder(container.Uri)
{
Query = sas.TrimStart('?')
}).Uri.AbsoluteUri;
// Generate ClientConfig
var expires = TimeSpan.FromMinutes(_timeout).TotalSeconds.ToString(CultureInfo.CurrentCulture);
var chunk = container.ServiceClient.WriteBlockSizeInBytes.ToString(CultureInfo.CurrentCulture);
var config = string.Format("timeout={0},maxChunkSize={1}", expires, chunk);
return new { ServiceUri = service, ClientConfig = config };
}
static void upload(string UUID, string file)
{
try
{
string path = Path.GetFullPath(@""+file);
BlobContainerPermissions containerPermissions;
blobContainer = blobClient.GetContainerReference(UUID);
blobContainer.CreateIfNotExist();
containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;
blobContainer.SetPermissions(containerPermissions);
blobContainer = blobClient.GetContainerReference(UUID);
CloudBlob blob = blobContainer.GetBlobReference(UUID);
Console.WriteLine("Starting file upload");
blob.UploadFile(path);
Console.WriteLine("File upload complete\n");
}
catch (Exception e)
{
Console.WriteLine("Error uploading file: " + e);
}
}
// Setup Runtime Servers
private void SetupRuntimeServers()
{
string containerName = RoleEnvironment.GetConfigurationSettingValue("PHPApplicationsBackupContainerName");
string blobName = RoleEnvironment.GetConfigurationSettingValue("InstallationStatusConfigFileBlob");
// Create blob container
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference(containerName);
if (container.CreateIfNotExist())
{
BlobContainerPermissions containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Container;
container.SetPermissions(containerPermissions);
}
CloudBlob blob = container.GetBlobReference(blobName);
if (!BlobExists(blob))
{
// Serialize empty NameValueCollection to blob
NameValueCollection values = new NameValueCollection();
SoapFormatter ser = new SoapFormatter();
using (MemoryStream memoryStream = new MemoryStream())
{
ser.Serialize(memoryStream, values);
byte[] b = memoryStream.GetBuffer();
string serilizedNameValueCollection = Encoding.Default.GetString(b);
blob.UploadText(serilizedNameValueCollection);
}
}
else
{
// Setup Runtime Servers
vmManager.SetupRuntimeServers();
}
}
static void Main(string[] args)
{
try
{
// Variables for the cloud storage objects.
var storageAccount = new StorageAccount();
// Use the emulatedstorage account.
var cloudStorageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(storageAccount.Account, storageAccount.Key), storageAccount.Https);
// If you want to use Windows Azure cloud storage account, use the following
// code (after uncommenting) instead of the code above.
// cloudStorageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=http;AccountName=your_storage_account_name;AccountKey=your_storage_account_key");
// Create the blob client, which provides
// authenticated access to the Blob service.
CloudBlobClient blobClient = cloudStorageAccount.CreateCloudBlobClient();
// Get the container reference.
Console.Write("input your container:");
storageAccount.Container = Console.ReadLine();
CloudBlobContainer blobContainer = blobClient.GetContainerReference(storageAccount.Container);
// Create the container if it does not exist.
blobContainer.CreateIfNotExist();
// Set permissions on the container.
var containerPermissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
// This sample sets the container to have public blobs. Your application
// needs may be different. See the documentation for BlobContainerPermissions
// for more information about blob container permissions.
blobContainer.SetPermissions(containerPermissions);
var directory = GetDirectory();
var fileInfos = GetAllFiles(directory);
foreach (var @fileInfo in fileInfos)
{
CloudBlob blob = blobContainer.GetBlobReference(@fileInfo.FullName.Replace(directory,""));
// Upload a file from the local system to the blob.
Console.WriteLine("Starting file upload");
blob.UploadFile(@fileInfo.FullName); // File from emulated storage.
Console.WriteLine("File upload complete to blob: " + blob.Uri);
}
}
catch (StorageClientException e)
{
Console.WriteLine("Storage client error encountered: " + e.Message);
// Exit the application with exit code 1.
System.Environment.Exit(1);
}
catch (Exception e)
{
Console.WriteLine("Error encountered: " + e.Message);
// Exit the application with exit code 1.
System.Environment.Exit(1);
}
finally
{
// Exit the application.
System.Environment.Exit(0);
}
}
// Primary Key = 60VMAzM8UiGe5NuL5t6IMpXm8mo2qiuKkBJY5CQg8Pz2XtF0Dm57tVDP4oTvmlvc8AV8Gh4HWSFz9fmxeszVDA==
// Secondary Key = s+kNBQqwJR+1LPSeG1D5bWOVgWJ/snaxgP2Ar0K5jkrJYz0IOOde4wpXAy0lIb9TpYqtIQS6SVJhRQ1UobtxcQ==
public IBucket CreateBucket(string bucketName)
{
var blobContainer = blobStorage.GetContainerReference("bmaigorcloudmorphstorage");
blobContainer.CreateIfNotExist();
var containerPermissions = new BlobContainerPermissions();
containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;
blobContainer.SetPermissions(containerPermissions);
return new AzureBucket() { Name = bucketName, CloudBlobClient = blobStorage.GetContainerReference(bucketName) };
}
private void PushEventToStore(TableServiceContext context, Guid eventSourceId, IEnumerable<SourcedEvent> events)
{
var formatter = new BinaryFormatter();
var blobClient = _account.CreateCloudBlobClient();
foreach (var eventToPush in events)
{
using (var buffer = new MemoryStream())
{
var eventEntity = SourcedEventEntity.FromEventSource(eventToPush);
var rootContainer = blobClient.GetContainerReference("events");
rootContainer.CreateIfNotExist();
var permissions = new BlobContainerPermissions();
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
rootContainer.SetPermissions(permissions);
var blob = rootContainer.GetBlobReference(eventEntity.RowKey);
formatter.Serialize(buffer, eventToPush);
buffer.Seek(0, SeekOrigin.Begin);
blob.UploadFromStream(buffer);
context.AddObject(EVENTS_TABLE_NAME, eventEntity);
}
}
}
static CloudBlobContainer CreateContainer()
{
var c = client.GetContainerReference("userphotos");
BlobContainerPermissions permissions = new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Container
};
c.SetPermissions(permissions);
return c;
}
public string AddToBucket(string bucketName, string id, Stream stream)
{
var blobContainer = blobStorage.GetContainerReference(bucketName);
blobContainer.CreateIfNotExist();
var containerPermissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
};
blobContainer.SetPermissions(containerPermissions);
var blobReference = blobContainer.GetBlobReference(id);
blobReference.Properties.ContentType = "image/jpeg";
blobReference.UploadFromStream(stream);
return blobReference.Uri.ToString();
}
public static string writeIterationToBlob(string containerName,Int32 t, ref Int64[] Before,ref Int64[] After, ref bool[] State)
{
string baseUri = "";
string paddedContainer="";
SimulatorLibrary.generateDirectoryName(containerName, ref paddedContainer);
CloudBlobContainer blobContainer = BlobLibrary.initContainer(paddedContainer, ref baseUri);
int tries=0;
bool success=false;
string errors = "";
do
{
try
{
blobContainer.CreateIfNotExist();
success = true;
}
catch (Exception e)
{
BlobLibrary.logToBlog("error when creating iteration result blob. " + e.Message + " retrying...", AccountInfo.masterLog);
Console.WriteLine("error when creating iteration result blob. " + e.Message + " retrying...");
errors = errors + e.Message+"\n";
Thread.Sleep(3000);
tries++;
}
} while (tries < 5 && !success);
if (!success)
{
return errors;
}
var perms = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Container // Blob (see files if you know the name) or Container (enumerate like a directory)
};
blobContainer.SetPermissions(perms); // This line makes the blob public so it is available from a web browser (no magic needed to read it)
StreamWriter BeforeOutput = new StreamWriter(BlobLibrary.getBlobWriteStream(paddedContainer, paddedContainer + "." + Constants._UBeforeFileName + "." + t));
StreamWriter AfterOutput = new StreamWriter(BlobLibrary.getBlobWriteStream(paddedContainer, paddedContainer + "." + Constants._UAfterFileName + "." + t));
StreamWriter StateOutput = new StreamWriter(BlobLibrary.getBlobWriteStream(paddedContainer, paddedContainer + "." + Constants._SFileName + "." + t));
for (int i = 0; i < Before.Length; i++)
BeforeOutput.Write(Before[i] + ",");
for (int i = 0; i < After.Length; i++)
AfterOutput.Write(After[i] + ",");
for (int i = 0; i < State.Length; i++)
{
if (State[i])
StateOutput.Write("1,");
else
StateOutput.Write("0,");
}
BeforeOutput.Write("\n");
AfterOutput.Write("\n");
StateOutput.Write("\n");
BeforeOutput.Close();
AfterOutput.Close();
StateOutput.Close();
return "";
}
// Set container access control to container|blob|private.
// Return true on success, false if not found, throw exception on error.
// Set access level to container|blob|private.
public bool SetContainerACL(string containerName, string accessLevel)
{
try
{
CloudBlobContainer container = BlobClient.GetContainerReference(containerName);
BlobContainerPermissions permissions = new BlobContainerPermissions();
switch(accessLevel)
{
case "container":
permissions.PublicAccess = BlobContainerPublicAccessType.Container;
break;
case "blob":
permissions.PublicAccess = BlobContainerPublicAccessType.Blob;
break;
case "private":
default:
permissions.PublicAccess = BlobContainerPublicAccessType.Off;
break;
}
container.SetPermissions(permissions);
return true;
}
catch (StorageClientException ex)
{
if ((int)ex.StatusCode == 404)
{
return false;
}
throw;
}
}
public static CloudBlobContainer ConfigureBlobStorageContainer(string connString, bool deleteBlobs, string containerName, BlobContainerPublicAccessType containerAccessType)
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
var anonWebContainer = blobClient.GetContainerReference(containerName);
anonWebContainer.CreateIfNotExist();
if (deleteBlobs)
{
BlobRequestOptions blobRequestOptions = new BlobRequestOptions();
blobRequestOptions.UseFlatBlobListing = true;
foreach (var blob in anonWebContainer.ListBlobs(blobRequestOptions))
{
CloudBlockBlob blockBlob = blob as CloudBlockBlob;
if (blockBlob != null)
blockBlob.Delete();
CloudPageBlob pageBlob = blob as CloudPageBlob;
if (pageBlob != null)
pageBlob.Delete();
}
}
BlobContainerPermissions permissions = new BlobContainerPermissions();
permissions.PublicAccess = containerAccessType;
anonWebContainer.SetPermissions(permissions);
return anonWebContainer;
}
