public void CreateObject(string bucketName, Stream fileStream)
{
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(bucketName);
request.WithInputStream(fileStream);
request.CannedACL = S3CannedACL.PublicRead;
S3Response response = _client.PutObject(request);
response.Dispose();
}
/// <summary>
/// Writes byte array data into an S3 Bucket
/// </summary>
/// <param name="data">The byte array data to write to the bucket.</param>
/// <param name="location">The location as to where you want to save the data</param>
/// <param name="guid">The guid of the content you're uploading</param>
public void WriteObject(byte[] data, StorageLocations location, string guid)
{
// Do upload
var stream = new MemoryStream(data);
var keyName = string.Format("{0}/{1}.onx", StorageLocationToString(location), guid);
var request = new PutObjectRequest();
request.WithBucketName(Bucket).WithKey(keyName).WithInputStream(stream);
// Response
S3Response response = _client.PutObject(request);
response.Dispose();
stream.Dispose();
}
public void UploadFile(string bucketName, Stream uploadFileStream, string remoteFileName)
{
using (client = Amazon.AWSClientFactory.CreateAmazonS3Client(accessKeyID, secretAccessKeyID, config))
{
try
{
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(bucketName)
.WithCannedACL(S3CannedACL.PublicRead)
.WithKey(remoteFileName)
.WithInputStream(uploadFileStream);
using (S3Response response = client.PutObject(request))
{
WebHeaderCollection headers = response.Headers;
foreach (string key in headers.Keys)
{
//log headers ("Response Header: {0}, Value: {1}", key, headers.Get(key));
}
}
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null && (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") || amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
//log exception - ("Please check the provided AWS Credentials.");
}
else
{
//log exception -("An error occurred with the message '{0}' when writing an object", amazonS3Exception.Message);
}
}
}
}
public override string SavePrivate(string domain, string path, Stream stream, DateTime expires)
{
using (AmazonS3 client = GetClient())
{
var request = new PutObjectRequest();
string objectKey = MakePath(domain, path);
request.WithBucketName(_bucket)
.WithKey(objectKey)
.WithCannedACL(S3CannedACL.BucketOwnerFullControl)
.WithContentType("application/octet-stream")
.WithMetaData("private-expire", expires.ToFileTimeUtc().ToString());
var headers = new NameValueCollection();
headers.Add("Cache-Control", string.Format("public, maxage={0}", (int)TimeSpan.FromDays(5).TotalSeconds));
headers.Add("Etag", (DateTime.UtcNow.Ticks).ToString());
headers.Add("Last-Modified", DateTime.UtcNow.ToString("R"));
headers.Add("Expires", DateTime.UtcNow.Add(TimeSpan.FromDays(5)).ToString("R"));
headers.Add("Content-Disposition", "attachment");
request.AddHeaders(headers);
request.WithInputStream(stream);
client.PutObject(request);
//Get presigned url
GetPreSignedUrlRequest pUrlRequest = new GetPreSignedUrlRequest()
.WithBucketName(_bucket)
.WithExpires(expires)
.WithKey(objectKey)
.WithProtocol(Protocol.HTTP)
.WithVerb(HttpVerb.GET);
string url = client.GetPreSignedURL(pUrlRequest);
//TODO: CNAME!
return(url);
}
}
public void save_file(string folderName, string fileName, Stream fileStream)
{
// It's allowed to have an empty folder name.
// if (String.IsNullOrWhiteSpace(folderName)) throw new ArgumentNullException("folderName");
if (String.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("fileName");
}
if (fileStream == null)
{
throw new ArgumentNullException("fileStream");
}
folderName = (string.IsNullOrEmpty(folderName) ? String.Empty : folderName.Substring(folderName.Length - 1, 1) == "/" ? folderName : folderName + "/");
fileName = string.Format("{0}{1}", folderName, fileName);
var request = new PutObjectRequest();
request.WithBucketName(clientContext.BucketName);
request.WithKey(fileName);
request.WithInputStream(fileStream);
request.AutoCloseStream = true;
request.CannedACL = S3CannedACL.PublicRead;
request.WithTimeout((int)TimeSpan.FromMinutes(30).TotalMilliseconds);
using (AmazonS3 client = clientContext.create_instance())
{
S3Response response = wrap_request_in_error_handler(() => client.PutObject(request));
}
}
public void SaveFile(string folderName, string fileName, Stream fileStream)
{
//folder ignored - packages stored on top level of S3 bucket
if (String.IsNullOrWhiteSpace(folderName))
{
throw new ArgumentNullException("folderName");
}
if (String.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("fileName");
}
if (fileStream == null)
{
throw new ArgumentNullException("fileStream");
}
var request = new PutObjectRequest();
request.WithBucketName(clientContext.BucketName);
request.WithKey(fileName);
request.WithInputStream(fileStream);
request.AutoCloseStream = true;
request.CannedACL = S3CannedACL.PublicRead;
request.WithTimeout((int)TimeSpan.FromMinutes(30).TotalMilliseconds);
using (AmazonS3 client = clientContext.CreateInstance())
{
S3Response response = WrapRequestInErrorHandler(() => client.PutObject(request));
}
}
public static bool WriteLogFile(string uploadFilePath, string credentialFilePath)
{
Type t = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
LogEvents.S3UploadStarted(t, uploadFilePath);
try
{
if (ReadS3Credentials(credentialFilePath) == false)
{
LogEvents.S3NoCredentials(t);
return(false);
}
AmazonS3 client = Amazon.AWSClientFactory.CreateAmazonS3Client(_accessKeyId, _secretAccessKey);
PutObjectRequest request = new PutObjectRequest();
string fileName = System.IO.Path.GetFileName(uploadFilePath);
request.WithFilePath(uploadFilePath).WithBucketName(_bucketName).WithKey(fileName);
S3Response responseWithMetadata = client.PutObject(request);
return(true);
}
catch (AmazonS3Exception amazonS3Exception)
{
LogEvents.S3Error(t, amazonS3Exception);
return(false);
}
}
private void putWithRetry(PutObjectRequest request)
{
// Retry put request up to five times
for (int i = 0; i < properties.S3MaxErrorRetry; i++)
{
try
{
// Attempt to put the object
s3.PutObject(request);
log.Info("Successfully uploaded file to S3: " + request.ToString());
return;
}
catch (AmazonS3Exception exception)
{
log.Info("Failed to upload file to S3: " + exception.ToString());
Thread.Sleep(properties.S3RetryDelayInterval);
}
catch (Exception e) {
log.Info("Failed to upload file to S3: " + e.ToString());
Thread.Sleep(properties.S3RetryDelayInterval);
}
}
throw new AmazonS3Exception("Failed to upload file to S3");
}
public static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure();
log.Info("Initializing and connecting to AWS...");
s3 = AWSClientFactory.CreateAmazonS3Client(RegionEndpoint.USWest1);
indexer = new FileIndexer("Files");
indexer.Index();
s3indexer = new S3Indexer(Settings.Default.BucketName, Settings.Default.FolderName, "S3Tmp", s3);
s3indexer.Index();
log.Info("Comparing local index and remote index.");
var filesToUpload = (from filePair in indexer.FileIndex where !s3indexer.HashedFiles.ContainsKey(filePair.Key) || !s3indexer.HashedFiles[filePair.Key].SequenceEqual(filePair.Value) select filePair.Key).ToList();
var filesToDelete = (from filePair in s3indexer.HashedFiles where !indexer.FileIndex.ContainsKey(filePair.Key) select filePair.Key).ToList();
foreach(var fileDelete in filesToDelete)
{
log.Debug("Deleting file "+fileDelete);
s3.DeleteObject(new DeleteObjectRequest()
{
BucketName = Settings.Default.BucketName,
Key = Settings.Default.FolderName + "/" + fileDelete
});
}
foreach(var fileUpload in filesToUpload)
{
log.Debug("Uploading file "+fileUpload);
s3.PutObject(new PutObjectRequest()
{
BucketName = Settings.Default.BucketName,
Key = Settings.Default.FolderName + "/" + fileUpload,
AutoCloseStream = true,
InputStream = new FileStream("Files/" + fileUpload, FileMode.Open)
});
}
log.Info("Re-indexing files...");
using (MemoryStream stream = new MemoryStream())
{
Serializer.Serialize(stream, indexer.FileIndex);
stream.Position = 0;
s3.PutObject(new PutObjectRequest()
{
BucketName = Settings.Default.BucketName,
Key = Settings.Default.FolderName + "/" + "index.mhash",
InputStream = stream
});
}
log.Info("Done!");
Console.Read();
}
public void WriteFile(string filePath, string contents)
{
AmazonS3.PutObject(new PutObjectRequest
{
Key = SanitizePath(filePath),
BucketName = BucketName,
ContentBody = contents,
});
}
public void WriteFile(string filePath, Stream stream)
{
AmazonS3.PutObject(new PutObjectRequest
{
Key = SanitizePath(filePath),
BucketName = BucketName,
InputStream = stream,
});
}
static void WritingAnObject()
{
try
{
// simple object put
PutObjectRequest request = new PutObjectRequest();
request.WithContentBody("this is a test")
.WithBucketName(bucketName)
.WithKey(keyName);
S3Response response = client.PutObject(request);
response.Dispose();
// put a more complex object with some metadata and http headers.
PutObjectRequest titledRequest = new PutObjectRequest();
titledRequest.WithMetaData("title", "the title")
.WithContentBody("this object has a title")
.WithBucketName(bucketName)
.WithKey(keyName);
using (S3Response responseWithMetadata = client.PutObject(titledRequest))
{
WebHeaderCollection headers = response.Headers;
foreach (string key in headers.Keys)
{
Console.WriteLine("Response Header: {0}, Value: {1}", key, headers.Get(key));
}
}
}
catch (AmazonS3Exception amazonS3Exception)
{
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") ||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Please check the provided AWS Credentials.");
Console.WriteLine("If you haven't signed up for Amazon S3, please visit http://aws.amazon.com/s3");
}
else
{
Console.WriteLine("An error occurred with the message '{0}' when writing an object", amazonS3Exception.Message);
}
}
}
public override bool Execute()
{
RequireSecretKey();
AmazonS3 s3Client = AWSClientFactory.CreateAmazonS3Client(AccessKey, SecretKey);
string bucketName = Bucket.ItemSpec;
Log.LogMessage(MessageImportance.High, "Connecting to \"{0}\"", bucketName);
WarnIfUneven(Tuple.Create("Puts", Puts), Tuple.Create("Keys", Keys));
foreach (var tuple in Zip(Puts, Keys))
{
ITaskItem put = tuple.Item1;
ITaskItem keyItem = tuple.Item2;
string key = keyItem.ItemSpec.Replace('\\', '/').TrimStart('/');
if (!put.Exists())
{
Log.LogMessage(MessageImportance.Normal, "Skipping {0} because it does not exist", key);
continue;
}
if (_Cancel)
{
return(false);
}
var putObjectRequest = new PutObjectRequest
{
BucketName = bucketName,
FilePath = put.ItemSpec,
Key = key,
Timeout = -1,
ReadWriteTimeout = 300000 // 5 minutes in milliseconds
};
S3CannedACL cannedACL;
if (Enum.TryParse <S3CannedACL>(put.GetMetadata("CannedACL") ?? "", out cannedACL))
{
Log.LogMessage(MessageImportance.Normal, "Applying CannedACL: {0}", cannedACL);
putObjectRequest.CannedACL = cannedACL;
}
string contentType = put.GetMetadata("ContentType");
if (!string.IsNullOrWhiteSpace(contentType))
{
Log.LogMessage(MessageImportance.Normal, "Applying ContentType: {0}", contentType);
putObjectRequest.ContentType = contentType;
}
Log.LogMessage(MessageImportance.High, "Putting \"{0}\"", key);
using (var upload = s3Client.PutObject(putObjectRequest))
{
}
}
return(true);
}
/// <summary>
/// /////////////////////Create a new file in folder/////////////////
/// </summary>
/// <param name="client"></param>
public static void CreateNewFileInFolder(AmazonS3 client, string cmap, string clipping)
{
String FolderKey = clipping + "/" + "Demo Create File.txt";
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(cmap);
request.WithKey(S3_KEY);
request.WithContentBody("This is body of S3 object.");
client.PutObject(request);
}
/// <summary>
/// ///////////////////Create a new Folder///////////////////////////////
/// </summary>
/// <param name="client"></param>
public static void CreateNewFolder(AmazonS3 client, string cmap, string clipping)
{
String FolderKey = clipping + "/";
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(cmap);
request.WithKey(FolderKey);
request.WithContentBody("");
client.PutObject(request);
}
public static string CreateNewFolder(AmazonS3 client, string foldername)
{
String S3_KEY = foldername;
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(BUCKET_NAME);
request.WithKey(S3_KEY);
request.WithContentBody("");
client.PutObject(request);
return S3_KEY;
}
public static string CreateNewFolder(AmazonS3 client, string foldername)
{
String S3_KEY = foldername;
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(BUCKET_NAME);
request.WithKey(S3_KEY);
request.WithContentBody("");
client.PutObject(request);
return(S3_KEY);
}
public static string CreateNewFileInFolder(AmazonS3 client, string foldername, string filepath)
{
String S3_KEY = foldername + "/" + System.IO.Path.GetFileName(filepath);
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(BUCKET_NAME);
request.WithKey(S3_KEY);
request.WithFilePath(filepath);
//request.WithContentBody("This is body of S3 object.");
client.PutObject(request);
return S3_KEY;
}
/// <summary>
/// ////////////////// Upload a new file//////////////////////////////////
/// </summary>
/// <param name="client"></param>
public static void UploadFile(AmazonS3 client)
{
//S3_KEY is name of file we want upload
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(BUCKET_NAME);
request.WithKey(S3_KEY);
//request.WithInputStream(MemoryStream);
request.WithFilePath(File_Path);
client.PutObject(request);
//Console.WriteLine("Yay");
}
public static string CreateNewFileInFolder(AmazonS3 client, string foldername, string filepath)
{
String S3_KEY = foldername + "/" + System.IO.Path.GetFileName(filepath);
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(BUCKET_NAME);
request.WithKey(S3_KEY);
request.WithFilePath(filepath);
//request.WithContentBody("This is body of S3 object.");
client.PutObject(request);
return(S3_KEY);
}
public static string UploadFile(AmazonS3 client, string filepath)
{
//S3_KEY is name of file we want upload
S3_KEY = System.IO.Path.GetFileName(filepath);
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(BUCKET_NAME);
request.WithKey(S3_KEY);
//request.WithInputStream(MemoryStream);
request.WithFilePath(filepath);
client.PutObject(request);
return(S3_KEY);
}
private static void PutObject(AmazonS3 s3Client, string bucket, string key)
{
var putObjectRequest = new PutObjectRequest();
putObjectRequest.WithBucketName(bucket)
.WithKey(key)
.WithContentType("text/plain")
.WithContentBody(key);
var objectResponse = s3Client.PutObject(putObjectRequest);
objectResponse.Dispose();
}
/// <summary>
/// Store the content from a local file into a bucket.
/// The key is the path under which the file will be stored.
/// </summary>
/// <param name="bucketName">The name of the bucket.</param>
/// <param name="key">The key under which the file will be available afterwards.</param>
/// <param name="file">The path to the local file.</param>
/// <param name="publicRead">Flag which indicates if the file is publicly available or not.</param>
/// <param name="timeoutMilliseconds">The timeout in milliseconds within the upload must have happend.</param>
public void PutFile(string bucketName, string key, string file, bool publicRead, int timeoutMilliseconds)
{
var request = new PutObjectRequest
{
CannedACL = publicRead ? S3CannedACL.PublicRead : S3CannedACL.Private,
FilePath = file,
BucketName = bucketName,
Key = key,
Timeout = timeoutMilliseconds
};
_amazonS3.PutObject(request);
}
public static void Put(string bucket, string key, string fileName)
{
AmazonS3 s3Client = AWSClientFactory.CreateAmazonS3Client();
FileInfo file = new FileInfo(fileName);
Console.Write("Uploading " + file.Name + " to " + bucket + ":" + key + file.Name);
PutObjectRequest po_req = new PutObjectRequest();
po_req.BucketName = bucket;
po_req.Key = key + file.Name;
po_req.FilePath = fileName;
po_req.AutoCloseStream = true;
PutObjectResponse po_res = s3Client.PutObject(po_req);
Console.WriteLine(po_res.AmazonId2);
}
public void TestInitialize()
{
try
{
this.objKey = Guid.NewGuid().ToString("N");
var putRequest = new PutObjectRequest()
.WithBucketName(bucket.BucketName)
.WithKey(this.objKey)
.WithContentBody(ObjectContent_Before);
using (var putResponse = client.PutObject(putRequest)) { }
}
catch (Exception e)
{
Assert.Inconclusive("prerequisite: unable to create object. Error: {0}", e.Message);
}
}
public string Sling(string path)
{
string token = Guid.NewGuid().ToString("N");
string zipPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
ICSharpCode.SharpZipLib.Zip.FastZip fz = new ICSharpCode.SharpZipLib.Zip.FastZip();
fz.CreateZip(zipPath, path, true, "", "");
using (AmazonS3 client = Amazon.AWSClientFactory.CreateAmazonS3Client("accesskey", "secret")) {
try {
// simple object put
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName("slingshot")
.WithKey(token + ".zip")
.WithCannedACL(S3CannedACL.PublicRead)
.WithFilePath(zipPath);
using (S3Response response = client.PutObject(request)) {
// work with it
Console.WriteLine(response.AmazonId2);
}
}
catch (AmazonS3Exception amazonS3Exception) {
if (amazonS3Exception.ErrorCode != null &&
(amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") ||
amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
{
Console.WriteLine("Please check the provided AWS Credentials.");
Console.WriteLine("If you haven't signed up for Amazon S3, please visit http://aws.amazon.com/s3");
}
else
{
Console.WriteLine("An error occurred with the message '{0}' when writing an object", amazonS3Exception.Message);
}
}
}
if (File.Exists(zipPath))
{
File.Delete(zipPath);
}
return(token);
}
/// <summary>
/// Copies the file from the local file system to S3.
/// If the file already exists in S3 and overwrite is set to false than an ArgumentException is thrown.
/// </summary>
/// <param name="srcFileName">Location of the file on the local file system to copy.</param>
/// <param name="overwrite">Determines whether the file can be overwritten.</param>
/// <exception cref="T:System.IO.IOException">If the file already exists in S3 and overwrite is set to false.</exception>
/// <exception cref="T:System.Net.WebException"></exception>
/// <exception cref="T:Amazon.S3.AmazonS3Exception"></exception>
/// <returns>S3FileInfo where the file is copied to.</returns>
public S3FileInfo CopyFromLocal(string srcFileName, bool overwrite)
{
if (!overwrite)
{
if (Exists)
{
throw new IOException("File already exists");
}
}
s3Client.PutObject(new PutObjectRequest()
.WithBucketName(bucket)
.WithKey(S3Helper.EncodeKey(key))
.WithFilePath(srcFileName)
.WithBeforeRequestHandler(S3Helper.FileIORequestEventHandler) as PutObjectRequest);
return(this);
}
private void BackUpToAmazon(AmazonS3 client)
{
try
{
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(this.BucketName).WithKey(FileLocations.CONFIG_FILENAME)
.WithFilePath(settings.FileLocations.Configuration);
client.PutObject(request);
this.ErrorLabel.ForeColor = Color.Black;
this.ErrorLabel.Text = "The backup was a success!";
}
catch (Exception exception)
{
this.ErrorLabel.ForeColor = Color.Red;
this.ErrorLabel.Text = exception.Message;
}
}
public void SaveObject(Stream fileContents, string fileName)
{
if (fileContents == null)
{
throw new ArgumentNullException("fileContents");
}
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentException("File name is required.", "fileName");
}
try
{
using (AmazonS3 client = CreateS3Client())
{
if (DoesBucketExist(client) == false)
{
SetupBucket(client);
}
PutObjectRequest objectRequest = new PutObjectRequest().WithBucketName(BucketName).WithKey(fileName);
if (fileContents.CanSeek)
{
fileContents.Position = 0;
}
objectRequest.InputStream = fileContents;
client.PutObject(objectRequest);
}
}
catch (AmazonS3Exception s3Ex)
{
throw AnAwsRelatedException(s3Ex);
}
catch (Exception ex)
{
throw new StorageException("An error occurred while processing your request.", ex);
}
}
private static void ResizeAndUpload(Stream aStream, AmazonS3 anS3Client, string aBucketName, string aNewImageName, int aSize)
{
Image myOriginal = Image.FromStream(aStream);
Image myActual = ScaleBySize(myOriginal, aSize);
MemoryStream myMemoryStream = imageToMemoryStream(myActual);
PutObjectRequest myRequest = new PutObjectRequest();
myRequest.WithBucketName(aBucketName)
.WithCannedACL(S3CannedACL.PublicRead)
.WithKey(aNewImageName)
.InputStream = myMemoryStream;
S3Response myResponse = anS3Client.PutObject(myRequest);
myActual.Dispose();
myMemoryStream.Dispose();
myOriginal.Dispose();
}
private void UploadEvents(LoggingEvent[] events, AmazonS3 client)
{
var key = Filename(Guid.NewGuid().ToString());
var content = new StringBuilder(events.Count());
Array.ForEach(events, logEvent =>
{
using (var writer = new StringWriter())
{
Layout.Format(writer, logEvent);
content.AppendLine(writer.ToString());
}
});
var request = new PutObjectRequest();
request.WithBucketName(_bucketName);
request.WithKey(key);
request.WithContentBody(content.ToString());
client.PutObject(request);
}
void UploadContent(string key, Stream content)
{
var request = new PutObjectRequest()
.WithBucketName(bucket)
.WithKey(key)
.WithCannedACL(cannedACL)
.WithInputStream(content) as PutObjectRequest;
if (headers != null)
{
request.AddHeaders(headers);
}
//TODO: handle exceptions properly
s3client.PutObject(request);
if (invalidator != null)
{
invalidator.InvalidateObject(bucket, key);
}
}
public bool UploadFileToS3(string uploadAsFileName, Stream ImageStream, S3CannedACL filePermission, S3StorageClass storageType)
{
try
{
AmazonS3 client = Amazon.AWSClientFactory.CreateAmazonS3Client("AKIAJ4A6DAATIDU6ELAA", "EiA6EILkCp7pqzvnIUhXg3FFOft0j+pA/DtBM8if");
PutObjectRequest request = new PutObjectRequest();
request.WithKey("folder" + "/" + uploadAsFileName);
request.WithInputStream(ImageStream);
request.WithBucketName("shriners_rms");
request.CannedACL = filePermission;
request.StorageClass = storageType;
client.PutObject(request);
client.Dispose();
}
catch
{
return(false);
}
return(true);
}
public static String UploadToS3(string fileName, Stream fileContent)
{
if (String.IsNullOrEmpty(fileName))
{
return("");
}
AmazonS3 s3Client = Amazon.AWSClientFactory.CreateAmazonS3Client("AKIAJ4A6DAATIDU6ELAA", "EiA6EILkCp7pqzvnIUhXg3FFOft0j+pA/DtBM8if");
PutObjectRequest putObjectRequest = new PutObjectRequest();
putObjectRequest.WithBucketName("shriners_rms");
putObjectRequest.CannedACL = S3CannedACL.PublicRead;
putObjectRequest.Key = fileName;
putObjectRequest.InputStream = fileContent;
S3Response response = s3Client.PutObject(putObjectRequest);
response.Dispose();
return("http://shriners_rms.s3.amazonaws.com/" + fileName);
}
/// <summary>
/// Saves an HTTP POSTed file
/// </summary>
/// <param name="localFile">HTTP POSTed file</param>
/// <param name="path">Web path to file's folder</param>
/// <param name="fileName">File name</param>
public void SaveFile(string localFile, string path, string fileName)
{
// Check if the local file exsit
if (!File.Exists(localFile))
{
return;
}
// Prepare put request
var request = new PutObjectRequest();
request.WithBucketName(_bucketName)
.WithCannedACL(S3CannedACL.PublicRead)
.WithFilePath(localFile)
.WithKey(GetKey(path, fileName))
.WithTimeout(-1);
// Put file
var response = _client.PutObject(request);
response.Dispose();
}
public void WalkAndUpload(string path, string bucket, AmazonS3 client)
{
foreach (var f in Directory.GetFiles(path))
{
var fi = new FileInfo(f);
if (fi.Name.StartsWith("."))
{
continue;
} //ignore ".gitignore"
string fileToPush = f;
string destinationName =
Regex.Split(fileToPush, @"gitCheckout-[\d]*")[1].Replace("\\", "/").TrimStart("/".ToCharArray());
var poR = new PutObjectRequest()
{
BucketName = bucket,
FilePath = fileToPush,
Key = destinationName,
Timeout = -1,
ReadWriteTimeout = 300000,
CannedACL = S3CannedACL.PublicRead
};
var res = client.PutObject(poR);
}
foreach (var d in Directory.GetDirectories(path))
{
var di = new DirectoryInfo(d);
if (di.Name.StartsWith("."))
{
continue;
} //ignore ".git"
WalkAndUpload(d, bucket, client);
}
}
public void putInS3Bucket(resume resume, string txtResults, string[] generatedFiles, string storedFilePath, string generatedFilePath)
{
using (client = Amazon.AWSClientFactory.CreateAmazonS3Client("AKIAJ47VSG7WMA62WLCA", "3tqlHujlftpk6j/z5OtDw2eg9N2FJtz1RwL8bEa3"))
{
string keyName;
S3Response response;
if (resume.hasIMG)
{
var pageNo = 0;
var append = false;
foreach (string fileName in generatedFiles)
{
keyName = "img/" + resume.resumeID.ToString();
keyName = append ? (keyName + "_" + pageNo.ToString()) : keyName;
PutObjectRequest imgRequest = new PutObjectRequest();
imgRequest.WithBucketName("intelrecruiter")
.WithCannedACL(S3CannedACL.PublicRead)
.WithFilePath(fileName)
.WithKey(keyName);
response = client.PutObject(imgRequest);
response.Dispose();
append = true;
pageNo++;
}
}
if (resume.hasTXT)
{
keyName = "txt/" + resume.resumeID.ToString();
PutObjectRequest txtRequest = new PutObjectRequest();
if (resume.hasDOCX)
{
txtRequest.WithBucketName("intelrecruiter")
.WithCannedACL(S3CannedACL.PublicRead)
.WithContentBody(txtResults)
.WithKey(keyName);
}
else
{
txtRequest.WithBucketName("intelrecruiter")
.WithCannedACL(S3CannedACL.PublicRead)
.WithFilePath(generatedFilePath)
.WithKey(keyName);
}
response = client.PutObject(txtRequest);
response.Dispose();
}
if (resume.hasPDF)
{
keyName = "pdf/" + resume.resumeID.ToString();
PutObjectRequest pdfRequest = new PutObjectRequest();
pdfRequest.WithBucketName("intelrecruiter")
.WithCannedACL(S3CannedACL.PublicRead)
.WithFilePath(storedFilePath)
.WithKey(keyName);
response = client.PutObject(pdfRequest);
response.Dispose();
}
if (resume.hasDOCX)
{
keyName = "docx/" + resume.resumeID.ToString();
PutObjectRequest imgRequest = new PutObjectRequest();
imgRequest.WithBucketName("intelrecruiter")
.WithCannedACL(S3CannedACL.PublicRead)
.WithFilePath(storedFilePath)
.WithKey(keyName);
response = client.PutObject(imgRequest);
response.Dispose();
}
}
}
private void saveSession(Cookie cookie)
{
string cookieName = cookie.Name;
string cookieValue = cookie.Value;
using (client = Amazon.AWSClientFactory.CreateAmazonS3Client("AKIAJ47VSG7WMA62WLCA", "3tqlHujlftpk6j/z5OtDw2eg9N2FJtz1RwL8bEa3"))
{
PutObjectRequest txtRequest = new PutObjectRequest();
txtRequest.WithBucketName("intelrecruiter")
.WithContentBody(cookieName)
.WithKey(nsbeCookieNameKey);
var response = client.PutObject(txtRequest);
response.Dispose();
txtRequest = new PutObjectRequest();
txtRequest.WithBucketName("intelrecruiter")
.WithContentBody(cookieValue)
.WithKey(nsbeCookieValueKey);
response = client.PutObject(txtRequest);
response.Dispose();
}
nsbeCookie = new Cookie(cookieName, cookieValue, "/");
}
public static string UploadFile(AmazonS3 client, string filepath)
{
//S3_KEY is name of file we want upload
S3_KEY = System.IO.Path.GetFileName(filepath);
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(BUCKET_NAME);
request.WithKey(S3_KEY);
//request.WithInputStream(MemoryStream);
request.WithFilePath(filepath);
client.PutObject(request);
return S3_KEY;
}
private static void PutObject(AmazonS3 s3Client, string bucket, string key)
{
var putObjectRequest = new PutObjectRequest();
putObjectRequest.WithBucketName(bucket)
.WithKey(key)
.WithContentType("text/plain")
.WithContentBody(key);
var objectResponse = s3Client.PutObject(putObjectRequest);
objectResponse.Dispose();
}
private bool AddImageToAmazon(Coupon coupon, HttpPostedFile File, string ext)
{
string count = "";
string keyname = "";
//ext = ".jpg";
//try
//{
string accessKeyID = WebConfigurationManager.AppSettings["AWSAccessKey"];
string secretAccessKeyID = WebConfigurationManager.AppSettings["AWSSecretKey"];
AmazonS3Config s3Config = new AmazonS3Config();
s3Config.UseSecureStringForAwsSecretKey = false;
client = Amazon.AWSClientFactory.CreateAmazonS3Client(accessKeyID, secretAccessKeyID, s3Config);
//count += "1";
ICouponDAO couponDAO = _factoryDAO.GetCouponDAO();
Byte[] imgByte = new byte[0];
//count += "2";
//Create byte Array with file len
imgByte = new Byte[File.ContentLength];
//count += "3";
//force the control to load data in array
File.InputStream.Read(imgByte, 0, File.ContentLength);
//count += "4";
//count += ext;
//count += _merchantname;
//count += _couponID.ToString();
//count += File.FileName;
//count += File.FileName.Substring(0, File.FileName.IndexOf("."));
//count += ":";
//count += string.Format("{0}{1}", _couponID.ToString(), ext);
keyname = string.Format("{0}/{1}", _merchantname, File.FileName.Replace(File.FileName.Substring(0, File.FileName.IndexOf(".")), string.Format("{0}{1}", _couponID.ToString(), ext)));
//keyname = string.Format("{0}/{1}", _merchantname, File.FileName.Replace(File.FileName.Substring(0, File.FileName.IndexOf(".")), _couponID.ToString()));
count += keyname;
/*try
{
//first try deleting old item if applicable
DeleteObjectRequest delete_request = new DeleteObjectRequest();
delete_request.WithBucketName("gfck").WithKey(string.Format("coupon/{0}", keyname));
S3Response delete_response = client.DeleteObject(delete_request);
delete_response.Dispose();
}
catch (Exception ex)
{
_log.ErrorFormat("Error trying to delete object from bucket: {0} with exception {1}", keyname, ex.Message);
}*/
string BUCKET_NAME = String.Format("gfck/coupon/{0}", _merchantname);
try
{
//add the bucket just in case not already there.
//PutObjectRequest request1 = new PutObjectRequest();
PutBucketRequest req = new PutBucketRequest();
req.WithBucketName(BUCKET_NAME);
//count += "6";
//request1.WithBucketName("gfck").WithContentType(File.ContentType).WithCannedACL(S3CannedACL.PublicReadWrite).WithKey(BUCKET_NAME);
//S3Response response = client.PutObject(request1);
//response.Dispose();
client.PutBucket(req);
}
catch (Exception ex)
{
_log.DebugFormat("This bucket already exists: {0} with exception {1}", BUCKET_NAME, ex.Message);
}
//count += "5";
PutObjectRequest request = new PutObjectRequest();
//count += "6";
request.WithBucketName("gfck").WithContentType(File.ContentType).WithCannedACL(S3CannedACL.PublicRead).WithKey(string.Format("coupon/{0}", keyname)).WithInputStream(File.InputStream);
count += "here";
S3Response response = client.PutObject(request);
count += "7";
response.Dispose();
count += "8";
if (ext == "")
{
coupon.Image = keyname;
}
else
{
coupon.BottomAdvertisement = keyname;
}
count += "9";
return couponDAO.UpdateCoupon(coupon);
/*}
catch (Exception ex)
{
_log.ErrorFormat("Exception Occurred: Exception={0}", ex.Message);
lblError.Text = String.Format("Error with coupon image. {0} {1} {2}", count, keyName, ex.Message);
lblError.Visible = true;
lblAddSuccessfull.Visible = false;
lblEditSuccessfull.Visible = false;
return false;
}*/
}
public ActionResult GetAll(int[] resumesToDelete)
{
string executableDir = Server.MapPath("~/executables");
resume resume;
ResumeFiles resumeFileRequest = new ResumeFiles();
var zipName = User.Identity.Name;
var fileName = zipName + ".zip";
string uploadDir = getUploadDir();
Directory.SetCurrentDirectory(uploadDir);
foreach (int resumeID in resumesToDelete)
{
resume = resumeRepository.GetResume(resumeID);
resumeFileRequest.getFilefromS3(resume, zipName);
}
var command = "\"" + executableDir + "\\7za\" a " + fileName + " " + zipName;
ExecuteCommandSync(command);
var fullPath = Path.Combine(uploadDir, fileName);
var folderPath = Path.Combine(uploadDir, zipName);
string contentType = "application/zip";
string keyName = "user_downloads/" + fileName;
using (client = Amazon.AWSClientFactory.CreateAmazonS3Client("AKIAJ47VSG7WMA62WLCA", "3tqlHujlftpk6j/z5OtDw2eg9N2FJtz1RwL8bEa3"))
{
S3Response response;
PutObjectRequest s3request = new PutObjectRequest();
s3request.WithBucketName("intelrecruiter")
.WithCannedACL(S3CannedACL.PublicRead)
.WithFilePath(fullPath)
.WithKey(keyName);
response = client.PutObject(s3request);
response.Dispose();
}
FileInfo newFile = new FileInfo(fullPath);
newFile.Delete();
DirectoryInfo dir = new DirectoryInfo(folderPath);
dir.Delete(true);
return RedirectToAction("List", new { user_download = keyName });
//return File(fullPath, contentType, zipName + ".zip");
/*
FileInfo newFile = new FileInfo(fullPath);
string attachment = string.Format("attachment; filename={0}", fileName);
Response.Clear();
Response.AddHeader("content-disposition", attachment);
Response.ContentType = contentType;
Response.WriteFile(newFile.FullName);
Response.Flush();
newFile.Delete();
DirectoryInfo dir = new DirectoryInfo(folderPath);
dir.Delete(true);
*/
//return RedirectToAction("Index");
}
private void BackUpToAmazon(AmazonS3 client)
{
try
{
PutObjectRequest request = new PutObjectRequest();
request.WithBucketName(this.BucketName).WithKey(FileLocations.CONFIG_FILENAME)
.WithFilePath(settings.FileLocations.Configuration);
client.PutObject(request);
this.ErrorLabel.ForeColor = Color.Black;
this.ErrorLabel.Text = "The backup was a success!";
}
catch (Exception exception)
{
this.ErrorLabel.ForeColor = Color.Red;
this.ErrorLabel.Text = exception.Message;
}
}