public ActionResult CKEditorUpload(string CKEditorFuncNum)
{
var m = new AccountModel();
string baseurl = null;
if (Request.Files.Count == 0)
return Content("");
var file = Request.Files[0];
var fn = $"{DbUtil.Db.Host}.{DateTime.Now:yyMMddHHmm}.{m.CleanFileName(Path.GetFileName(file.FileName))}";
var error = string.Empty;
var rackspacecdn = ConfigurationManager.AppSettings["RackspaceUrlCDN"];
if (rackspacecdn.HasValue())
{
baseurl = rackspacecdn;
var username = ConfigurationManager.AppSettings["RackspaceUser"];
var key = ConfigurationManager.AppSettings["RackspaceKey"];
var cloudIdentity = new CloudIdentity {APIKey = key, Username = username};
var cloudFilesProvider = new CloudFilesProvider(cloudIdentity);
cloudFilesProvider.CreateObject("AllFiles", file.InputStream, fn);
}
else // local server
{
baseurl = $"{Request.Url.Scheme}://{Request.Url.Authority}/Upload/";
try
{
var path = Server.MapPath("/Upload/");
path += fn;
path = m.GetNewFileName(path);
file.SaveAs(path);
}
catch (Exception ex)
{
error = ex.Message;
baseurl = string.Empty;
}
}
return Content($"<script type='text/javascript'>window.parent.CKEDITOR.tools.callFunction( {CKEditorFuncNum}, '{baseurl + fn}', '{error}' );</script>");
}
public ActionResult FroalaUpload(HttpPostedFileBase file)
{
var m = new AccountModel();
string baseurl = null;
var fn = $"{DbUtil.Db.Host}.{DateTime.Now:yyMMddHHmm}.{m.CleanFileName(Path.GetFileName(file.FileName))}";
var error = string.Empty;
var rackspacecdn = ConfigurationManager.AppSettings["RackspaceUrlCDN"];
if (rackspacecdn.HasValue())
{
baseurl = rackspacecdn;
var username = ConfigurationManager.AppSettings["RackspaceUser"];
var key = ConfigurationManager.AppSettings["RackspaceKey"];
var cloudIdentity = new CloudIdentity {APIKey = key, Username = username};
var cloudFilesProvider = new CloudFilesProvider(cloudIdentity);
cloudFilesProvider.CreateObject("AllFiles", file.InputStream, fn);
}
else // local server
{
baseurl = $"{Request.Url.Scheme}://{Request.Url.Authority}/Upload/";
try
{
var path = Server.MapPath("/Upload/");
path += fn;
path = m.GetNewFileName(path);
file.SaveAs(path);
}
catch (Exception ex)
{
error = ex.Message;
baseurl = string.Empty;
}
}
return Json(new {link = baseurl + fn, error}, JsonRequestBehavior.AllowGet);
}
public void TestDeleteObjectMetaData()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
string objectData = "";
ObjectStore result = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, result);
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(objectData));
provider.CreateObject(containerName, stream, objectName);
Dictionary<string, string> metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "Key1", "Value 1" },
{ "Key2", "Value ²" },
{ "Key3", "Value 3" },
{ "Key4", "Value 4" },
};
provider.UpdateObjectMetadata(containerName, objectName, new Dictionary<string, string>(metadata, StringComparer.OrdinalIgnoreCase));
Dictionary<string, string> actualMetadata = provider.GetObjectMetaData(containerName, objectName);
Console.WriteLine("Object Metadata");
foreach (KeyValuePair<string, string> pair in actualMetadata)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
CheckMetadataCollections(metadata, actualMetadata);
/* Check the overload which takes a single key
*/
// remove Key3 first to make sure we still have a ² character in a remaining value
metadata.Remove("Key3");
provider.DeleteObjectMetadata(containerName, objectName, "Key3");
actualMetadata = provider.GetObjectMetaData(containerName, objectName);
Console.WriteLine("Object Metadata after removing Key3");
foreach (KeyValuePair<string, string> pair in actualMetadata)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
CheckMetadataCollections(metadata, actualMetadata);
/* Check the overload which takes multiple keys
*/
metadata.Remove("Key2");
metadata.Remove("Key4");
provider.DeleteObjectMetadata(containerName, objectName, new[] { "Key2", "Key4" });
actualMetadata = provider.GetObjectMetaData(containerName, objectName);
Console.WriteLine("Object Metadata after removing Key2, Key4");
foreach (KeyValuePair<string, string> pair in actualMetadata)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
CheckMetadataCollections(metadata, actualMetadata);
/* Check that duplicate removal is a NOP
*/
metadata.Remove("Key2");
metadata.Remove("Key4");
provider.DeleteObjectMetadata(containerName, objectName, new[] { "Key2", "Key4" });
actualMetadata = provider.GetObjectMetaData(containerName, objectName);
Console.WriteLine("Object Metadata after removing Key2, Key4");
foreach (KeyValuePair<string, string> pair in actualMetadata)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
CheckMetadataCollections(metadata, actualMetadata);
/* Cleanup
*/
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestUpdateObjectMetaData()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
string objectData = "";
string contentType = "text/plain-jane";
ObjectStore result = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, result);
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(objectData));
provider.CreateObject(containerName, stream, objectName, contentType);
Assert.AreEqual(contentType, GetObjectContentType(provider, containerName, objectName));
Dictionary<string, string> metadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "Key1", "Value 1" },
{ "Key2", "Value ²" },
};
provider.UpdateObjectMetadata(containerName, objectName, new Dictionary<string, string>(metadata, StringComparer.OrdinalIgnoreCase));
Assert.AreEqual(contentType, GetObjectContentType(provider, containerName, objectName));
Dictionary<string, string> actualMetadata = provider.GetObjectMetaData(containerName, objectName);
Console.WriteLine("Object Metadata");
foreach (KeyValuePair<string, string> pair in actualMetadata)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
CheckMetadataCollections(metadata, actualMetadata);
metadata["Key2"] = "Value 2";
Dictionary<string, string> updatedMetadata = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "Key2", "Value 2" }
};
provider.UpdateObjectMetadata(containerName, objectName, new Dictionary<string, string>(updatedMetadata, StringComparer.OrdinalIgnoreCase));
Assert.AreEqual(contentType, GetObjectContentType(provider, containerName, objectName));
actualMetadata = provider.GetObjectMetaData(containerName, objectName);
Console.WriteLine("Object Metadata");
foreach (KeyValuePair<string, string> pair in actualMetadata)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
CheckMetadataCollections(updatedMetadata, actualMetadata);
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestGetObjectHeaders()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
string objectData = "";
ObjectStore containerResult = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, containerResult);
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(objectData));
provider.CreateObject(containerName, stream, objectName);
Dictionary<string, string> headers = provider.GetObjectHeaders(containerName, objectName);
Assert.IsNotNull(headers);
Console.WriteLine("Headers");
foreach (var pair in headers)
{
Assert.IsFalse(string.IsNullOrEmpty(pair.Key));
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
}
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestStaticWebOnContainer()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
string fileContents = "File contents!";
ObjectStore result = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, result);
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(fileContents));
provider.CreateObject(containerName, stream, objectName);
Dictionary<string, string> cdnHeaders = provider.EnableCDNOnContainer(containerName, false);
Assert.IsNotNull(cdnHeaders);
Console.WriteLine("CDN Headers");
foreach (var pair in cdnHeaders)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
string index = objectName;
string error = objectName;
string css = objectName;
provider.EnableStaticWebOnContainer(containerName, index: index, error: error, listing: false);
provider.DisableStaticWebOnContainer(containerName);
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestCDNOnContainer()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
string fileContents = "File contents!";
ObjectStore result = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, result);
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(fileContents));
provider.CreateObject(containerName, stream, objectName);
Dictionary<string, string> cdnHeaders = provider.EnableCDNOnContainer(containerName, false);
Assert.IsNotNull(cdnHeaders);
Console.WriteLine("CDN Headers from EnableCDNOnContainer");
foreach (var pair in cdnHeaders)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
ContainerCDN containerHeader = provider.GetContainerCDNHeader(containerName);
Assert.IsNotNull(containerHeader);
Console.WriteLine(JsonConvert.SerializeObject(containerHeader, Formatting.Indented));
Assert.IsTrue(containerHeader.CDNEnabled);
Assert.IsFalse(containerHeader.LogRetention);
Assert.IsTrue(
containerHeader.CDNUri != null
|| containerHeader.CDNIosUri != null
|| containerHeader.CDNSslUri != null
|| containerHeader.CDNStreamingUri != null);
// Call the other overloads of EnableCDNOnContainer
cdnHeaders = provider.EnableCDNOnContainer(containerName, containerHeader.Ttl);
ContainerCDN updatedHeader = provider.GetContainerCDNHeader(containerName);
Console.WriteLine(JsonConvert.SerializeObject(updatedHeader, Formatting.Indented));
Assert.IsNotNull(updatedHeader);
Assert.IsTrue(updatedHeader.CDNEnabled);
Assert.IsFalse(updatedHeader.LogRetention);
Assert.IsTrue(
updatedHeader.CDNUri != null
|| updatedHeader.CDNIosUri != null
|| updatedHeader.CDNSslUri != null
|| updatedHeader.CDNStreamingUri != null);
Assert.AreEqual(containerHeader.Ttl, updatedHeader.Ttl);
cdnHeaders = provider.EnableCDNOnContainer(containerName, containerHeader.Ttl, true);
updatedHeader = provider.GetContainerCDNHeader(containerName);
Console.WriteLine(JsonConvert.SerializeObject(updatedHeader, Formatting.Indented));
Assert.IsNotNull(updatedHeader);
Assert.IsTrue(updatedHeader.CDNEnabled);
Assert.IsTrue(updatedHeader.LogRetention);
Assert.IsTrue(
updatedHeader.CDNUri != null
|| updatedHeader.CDNIosUri != null
|| updatedHeader.CDNSslUri != null
|| updatedHeader.CDNStreamingUri != null);
Assert.AreEqual(containerHeader.Ttl, updatedHeader.Ttl);
// update the container CDN properties
Dictionary<string, string> headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
{ CloudFilesProvider.CdnTTL, (updatedHeader.Ttl + 1).ToString() },
{ CloudFilesProvider.CdnLogRetention, false.ToString() },
//{ CloudFilesProvider.CdnEnabled, true.ToString() },
};
provider.UpdateContainerCdnHeaders(containerName, headers);
updatedHeader = provider.GetContainerCDNHeader(containerName);
Console.WriteLine(JsonConvert.SerializeObject(updatedHeader, Formatting.Indented));
Assert.IsNotNull(updatedHeader);
Assert.IsTrue(updatedHeader.CDNEnabled);
Assert.IsFalse(updatedHeader.LogRetention);
Assert.IsTrue(
updatedHeader.CDNUri != null
|| updatedHeader.CDNIosUri != null
|| updatedHeader.CDNSslUri != null
|| updatedHeader.CDNStreamingUri != null);
Assert.AreEqual(containerHeader.Ttl + 1, updatedHeader.Ttl);
// attempt to access the container over the CDN
if (containerHeader.CDNUri != null || containerHeader.CDNSslUri != null)
{
string baseUri = containerHeader.CDNUri ?? containerHeader.CDNSslUri;
Uri uri = new Uri(containerHeader.CDNUri + '/' + objectName);
WebRequest request = HttpWebRequest.Create(uri);
using (WebResponse response = request.GetResponse())
{
Stream cdnStream = response.GetResponseStream();
StreamReader reader = new StreamReader(cdnStream, Encoding.UTF8);
string text = reader.ReadToEnd();
Assert.AreEqual(fileContents, text);
}
}
else
{
Assert.Inconclusive("This integration test relies on cdn_uri or cdn_ssl_uri.");
}
IEnumerable<ContainerCDN> containers = ListAllCDNContainers(provider);
Console.WriteLine("Containers");
foreach (ContainerCDN container in containers)
{
Console.WriteLine(" {1}{0}", container.Name, container.CDNEnabled ? "*" : "");
}
cdnHeaders = provider.DisableCDNOnContainer(containerName);
Assert.IsNotNull(cdnHeaders);
Console.WriteLine("CDN Headers from DisableCDNOnContainer");
foreach (var pair in cdnHeaders)
Console.WriteLine(" {0}: {1}", pair.Key, pair.Value);
updatedHeader = provider.GetContainerCDNHeader(containerName);
Console.WriteLine(JsonConvert.SerializeObject(updatedHeader, Formatting.Indented));
Assert.IsNotNull(updatedHeader);
Assert.IsFalse(updatedHeader.CDNEnabled);
Assert.IsFalse(updatedHeader.LogRetention);
Assert.IsTrue(
updatedHeader.CDNUri != null
|| updatedHeader.CDNIosUri != null
|| updatedHeader.CDNSslUri != null
|| updatedHeader.CDNStreamingUri != null);
Assert.AreEqual(containerHeader.Ttl + 1, updatedHeader.Ttl);
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestDeleteObject()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
// another random name counts as random content
string fileData = Path.GetRandomFileName();
ObjectStore containerResult = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, containerResult);
using (MemoryStream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(fileData)))
{
provider.CreateObject(containerName, uploadStream, objectName);
}
string actualData = ReadAllObjectText(provider, containerName, objectName, Encoding.UTF8);
Assert.AreEqual(fileData, actualData);
provider.DeleteObject(containerName, objectName);
try
{
using (MemoryStream downloadStream = new MemoryStream())
{
provider.GetObject(containerName, objectName, downloadStream);
}
Assert.Fail("Expected an exception (object should not exist)");
}
catch (ResponseException)
{
}
/* Cleanup
*/
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestVersionedContainer()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string versionsContainerName = TestContainerPrefix + Path.GetRandomFileName();
ObjectStore result = provider.CreateContainer(versionsContainerName);
Assert.AreEqual(ObjectStore.ContainerCreated, result);
result = provider.CreateContainer(containerName, new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { CloudFilesProvider.VersionsLocation, versionsContainerName } });
Assert.AreEqual(ObjectStore.ContainerCreated, result);
Dictionary<string, string> headers = provider.GetContainerHeader(containerName);
string location;
Assert.IsTrue(headers.TryGetValue(CloudFilesProvider.VersionsLocation, out location));
Assert.AreEqual(versionsContainerName, location);
string objectName = Path.GetRandomFileName();
string fileData1 = "first-content";
string fileData2 = "second-content";
/*
* Create the object
*/
using (MemoryStream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(fileData1)))
{
provider.CreateObject(containerName, uploadStream, objectName);
}
string actualData = ReadAllObjectText(provider, containerName, objectName, Encoding.UTF8);
Assert.AreEqual(fileData1, actualData);
/*
* Overwrite the object
*/
using (MemoryStream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(fileData2)))
{
provider.CreateObject(containerName, uploadStream, objectName);
}
actualData = ReadAllObjectText(provider, containerName, objectName, Encoding.UTF8);
Assert.AreEqual(fileData2, actualData);
/*
* Delete the object once
*/
provider.DeleteObject(containerName, objectName);
actualData = ReadAllObjectText(provider, containerName, objectName, Encoding.UTF8);
Assert.AreEqual(fileData1, actualData);
/*
* Cleanup
*/
provider.DeleteContainer(versionsContainerName, deleteObjects: true);
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestGetObjectSaveToFile()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
// another random name counts as random content
string fileData = Path.GetRandomFileName();
ObjectStore containerResult = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, containerResult);
using (MemoryStream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(fileData)))
{
provider.CreateObject(containerName, uploadStream, objectName);
}
try
{
provider.GetObjectSaveToFile(containerName, Path.GetTempPath(), objectName);
Assert.AreEqual(fileData, File.ReadAllText(Path.Combine(Path.GetTempPath(), objectName), Encoding.UTF8));
// it's ok to download the same file twice
ProgressMonitor progressMonitor = new ProgressMonitor(GetContainerObjectSize(provider, containerName, objectName));
provider.GetObjectSaveToFile(containerName, Path.GetTempPath(), objectName, progressUpdated: progressMonitor.Updated);
Assert.IsTrue(progressMonitor.IsComplete, "Failed to notify progress monitor callback of status update.");
}
finally
{
File.Delete(Path.Combine(Path.GetTempPath(), objectName));
}
string tempFileName = Path.GetRandomFileName();
try
{
provider.GetObjectSaveToFile(containerName, Path.GetTempPath(), objectName, tempFileName);
Assert.AreEqual(fileData, File.ReadAllText(Path.Combine(Path.GetTempPath(), tempFileName), Encoding.UTF8));
// it's ok to download the same file twice
ProgressMonitor progressMonitor = new ProgressMonitor(GetContainerObjectSize(provider, containerName, objectName));
provider.GetObjectSaveToFile(containerName, Path.GetTempPath(), objectName, progressUpdated: progressMonitor.Updated);
Assert.IsTrue(progressMonitor.IsComplete, "Failed to notify progress monitor callback of status update.");
}
finally
{
File.Delete(Path.Combine(Path.GetTempPath(), tempFileName));
}
/* Cleanup
*/
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestCopyObject()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
string copiedName = Path.GetRandomFileName();
// another random name counts as random content
string fileData = Path.GetRandomFileName();
string contentType = "text/plain-jane";
ObjectStore containerResult = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, containerResult);
using (MemoryStream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(fileData)))
{
provider.CreateObject(containerName, uploadStream, objectName, contentType);
}
string actualData = ReadAllObjectText(provider, containerName, objectName, Encoding.UTF8);
Assert.AreEqual(fileData, actualData);
provider.CopyObject(containerName, objectName, containerName, copiedName);
// make sure the item is available at the copied location
actualData = ReadAllObjectText(provider, containerName, copiedName, Encoding.UTF8);
Assert.AreEqual(fileData, actualData);
// make sure the original object still exists
actualData = ReadAllObjectText(provider, containerName, objectName, Encoding.UTF8);
Assert.AreEqual(fileData, actualData);
// make sure the content type was not changed by the copy operation
Assert.AreEqual(contentType, GetObjectContentType(provider, containerName, objectName));
Assert.AreEqual(contentType, GetObjectContentType(provider, containerName, copiedName));
/* Cleanup
*/
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestCreateObject()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
// another random name counts as random content
string fileData = Path.GetRandomFileName();
ObjectStore containerResult = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, containerResult);
using (MemoryStream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(fileData)))
{
provider.CreateObject(containerName, uploadStream, objectName);
// it's ok to create the same file twice
uploadStream.Position = 0;
ProgressMonitor progressMonitor = new ProgressMonitor(uploadStream.Length);
provider.CreateObject(containerName, uploadStream, objectName, progressUpdated: progressMonitor.Updated);
Assert.IsTrue(progressMonitor.IsComplete, "Failed to notify progress monitor callback of status update.");
}
string actualData = ReadAllObjectText(provider, containerName, objectName, Encoding.UTF8);
Assert.AreEqual(fileData, actualData);
/* Cleanup
*/
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void TestSpecialCharacters()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string[] specialNames = { "#", " ", " lead", "trail ", "%", "x//x" };
// another random name counts as random content
string fileData = Path.GetRandomFileName();
foreach (string containerSuffix in specialNames)
{
string containerName = TestContainerPrefix + Path.GetRandomFileName() + containerSuffix;
ObjectStore containerResult = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, containerResult);
foreach (string objectName in specialNames)
{
using (MemoryStream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(fileData)))
{
provider.CreateObject(containerName, uploadStream, objectName);
}
}
Console.WriteLine("Objects in container {0}", containerName);
foreach (ContainerObject containerObject in ListAllObjects(provider, containerName))
{
Console.WriteLine(" {0}", containerObject.Name);
}
/* Cleanup
*/
provider.DeleteContainer(containerName, deleteObjects: true);
}
}
public void Should_Create_Object_From_Stream_With_Headers()
{
var etag = GetMD5Hash(objectName);
var headers = new Dictionary<string, string> {{"ETag", etag}};
var provider = new CloudFilesProvider(_testIdentity);
using (var stream = File.OpenRead(objectName))
{
provider.CreateObject(containerName, stream, objectName, headers: headers);
}
var containerGetObjectsResponse = provider.ListObjects(containerName, identity: _testIdentity);
Assert.AreEqual(objectName, containerGetObjectsResponse.Where(x => x.Name.Equals(objectName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault().Name);
var objectHeadersResponse = provider.GetObjectHeaders(containerName, objectName, identity: _testIdentity);
Assert.IsNotNull(objectHeadersResponse);
Assert.AreEqual(etag, objectHeadersResponse.Where(x => x.Key.Equals("ETag", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault().Value);
}
public void Should_Create_Object_From_Stream_With_Headers()
{
string fileName = objectName;
Stream stream = System.IO.File.OpenRead(objectName);
var etag = GetMD5Hash(objectName);
stream.Position = 0;
var headers = new Dictionary<string, string>();
headers.Add("ETag", etag);
int cnt = 0;
var info = new FileInfo(objectName);
var totalBytest = info.Length;
var provider = new CloudFilesProvider(_testIdentity);
provider.CreateObject(containerName, stream, fileName, 65536, headers, null, (bytesWritten) =>
{
cnt = cnt + 1;
if (cnt % 10 != 0)
return;
var x = (float)bytesWritten / (float)totalBytest;
var percentCompleted = (float)x * 100.00;
Console.WriteLine(string.Format("{0:0.00} % Completed (Writen: {1} of {2})", percentCompleted, bytesWritten, totalBytest));
});
var containerGetObjectsResponse = provider.ListObjects(containerName, identity: _testIdentity);
Assert.AreEqual(fileName, containerGetObjectsResponse.Where(x => x.Name.Equals(fileName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault().Name);
var objectHeadersResponse = provider.GetObjectHeaders(containerName, fileName, identity: _testIdentity);
Assert.IsNotNull(objectHeadersResponse);
Assert.AreEqual(etag, objectHeadersResponse.Where(x => x.Key.Equals("ETag", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault().Value);
}
public void TestDeleteContainer()
{
IObjectStorageProvider provider = new CloudFilesProvider(Bootstrapper.Settings.TestIdentity);
string containerName = TestContainerPrefix + Path.GetRandomFileName();
string objectName = Path.GetRandomFileName();
string fileContents = "File contents!";
ObjectStore result = provider.CreateContainer(containerName);
Assert.AreEqual(ObjectStore.ContainerCreated, result);
Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(fileContents));
provider.CreateObject(containerName, stream, objectName);
try
{
provider.DeleteContainer(containerName, deleteObjects: false);
Assert.Fail("Expected a ContainerNotEmptyException");
}
catch (ContainerNotEmptyException)
{
}
provider.DeleteContainer(containerName, deleteObjects: true);
}
public void Should_Create_Object_From_Stream_Without_Headers()
{
string fileName = objectName;
Stream stream = System.IO.File.OpenRead(objectName);
stream.Position = 0;
var headers = new Dictionary<string, string>();
var provider = new CloudFilesProvider(_testIdentity);
provider.CreateObject(containerName, stream, fileName, 65536, headers);
var containerGetObjectsResponse = provider.ListObjects(containerName, identity: _testIdentity);
Assert.AreEqual(fileName, containerGetObjectsResponse.Where(x => x.Name.Equals(fileName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault().Name);
}
public string UploadAttachment(HttpPostedFileBase file)
{
var m = new AccountModel();
string baseurl = null;
var fn = $"{DbUtil.Db.Host}.{DateTime.Now:yyMMddHHmm}.{m.CleanFileName(Path.GetFileName(file.FileName))}";
var error = string.Empty;
var rackspacecdn = DbUtil.Db.Setting("RackspaceUrlCDN", null);
string username;
string key;
if (string.IsNullOrEmpty(rackspacecdn))
{
rackspacecdn = ConfigurationManager.AppSettings["RackspaceUrlCDN"];
username = ConfigurationManager.AppSettings["RackspaceUser"];
key = ConfigurationManager.AppSettings["RackspaceKey"];
}
else
{
username = DbUtil.Db.Setting("RackspaceUser", null);
key = DbUtil.Db.Setting("RackspaceKey", null);
}
if (rackspacecdn.HasValue())
{
baseurl = rackspacecdn;
var cloudIdentity = new CloudIdentity { APIKey = key, Username = username };
var cloudFilesProvider = new CloudFilesProvider(cloudIdentity);
cloudFilesProvider.CreateObject("AllFiles", file.InputStream, fn);
}
else // local server
{
baseurl = $"{Request.Url.Scheme}://{Request.Url.Authority}/Upload/";
try
{
var path = Server.MapPath("/Upload/");
path += fn;
path = m.GetNewFileName(path);
file.SaveAs(path);
}
catch (Exception ex)
{
error = ex.Message;
baseurl = string.Empty;
}
}
return Util.URLCombine(baseurl, fn);
}
