Example #1
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (upload.PostedFile != null && upload.PostedFile.ContentLength > 0 && !string.IsNullOrEmpty(Request["awsid"]) && !string.IsNullOrEmpty(Request["awssecret"]) && !string.IsNullOrEmpty(this.bucket.Text))
            {
                var name = "s3readersample/" + ImageUploadHelper.Current.GenerateSafeImageName(upload.PostedFile.InputStream, upload.PostedFile.FileName);

                var client = new Amazon.S3.AmazonS3Client(Request["awsid"], Request["awssecret"], Amazon.RegionEndpoint.EUWest1);

                //For some reason we have to buffer the file in memory to prevent issues... Need to research further
                var ms = new MemoryStream();
                upload.PostedFile.InputStream.CopyTo(ms);
                ms.Seek(0, SeekOrigin.Begin);

                var request = new Amazon.S3.Model.PutObjectRequest() {  BucketName = this.bucket.Text, Key = name, InputStream = ms, CannedACL = Amazon.S3.S3CannedACL.PublicRead };

                var response = client.PutObject(request);
                if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
                {
                    result.Text = "Successfully uploaded " + name + "to bucket " + this.bucket.Text;

                }
                else
                {
                    result.Text = response.HttpStatusCode.ToString();
                }
            }
        }
        public ErrorTypes WriteFile(string strPath, System.IO.Stream oStream, out int nReadWriteBytes)
        {
            ErrorTypes eResult = ErrorTypes.StorageWrite;

            nReadWriteBytes = (int)oStream.Length;
            try
            {
                string strFileKey = GetFilePath(strPath);
                using (Amazon.S3.AmazonS3 oS3Client = Amazon.AWSClientFactory.CreateAmazonS3Client(m_oRegion))
                {
                    Amazon.S3.Model.PutObjectRequest oRequest = new Amazon.S3.Model.PutObjectRequest();
                    oRequest.WithBucketName(m_strBucketName).WithKey(strFileKey).WithInputStream(oStream);

                    using (Amazon.S3.Model.PutObjectResponse oResponse = oS3Client.PutObject(oRequest))
                    {
                        oResponse.Dispose();
                    }
                }
            }
            catch
            {
                nReadWriteBytes = 0;
            }

            return(eResult);
        }
Example #3
0
        public void UploadFile(Uri fileUrl, Stream s)
        {
            var filePath = fileUrl.AbsolutePath;

            // We need to strip off any leading '/' in the path or
            // else it creates a path with an empty leading segment
            if (filePath.StartsWith("/"))
            {
                filePath = filePath.Substring(1);
            }

            var s3 = new Amazon.S3.AmazonS3Client(
                AccessKeyId, SecretAccessKey, RegionEndpoint);

            var s3Requ = new Amazon.S3.Model.PutObjectRequest
            {
                BucketName      = BucketName,
                Key             = filePath,
                InputStream     = s,
                AutoCloseStream = false,
            };
            var s3Resp = s3.PutObject(s3Requ);

            if (DnsProvider != null)
            {
                var hostname = fileUrl.Host;
                DnsProvider.EditCnameRecord(hostname, DnsCnameTarget);
            }
            else
            {
                // TODO:  do nothing for now
                // Throw Exception???
            }
        }
        public async Task <String> SaveFileToAws(FileDto file)
        {
            var keyId     = _configuration.GetSection("AWS").GetValue <String>("AWSAccessKeyId");
            var keySecret = _configuration.GetSection("AWS").GetValue <String>("AWSSecretAccessKey");

            var config = new Amazon.S3.AmazonS3Config();

            config.RegionEndpoint = Amazon.RegionEndpoint.EUWest3;

            var client = new Amazon.S3.AmazonS3Client(keyId, keySecret, config);

            var fileName = $"users-uploads/{Guid.NewGuid().ToString()}-{file.FileName}";

            var request = new Amazon.S3.Model.PutObjectRequest
            {
                BucketName   = "teller-uploads",
                ContentType  = file.ContentType,
                InputStream  = file.ReadStream,
                Key          = fileName,
                StorageClass = Amazon.S3.S3StorageClass.Standard,
                CannedACL    = Amazon.S3.S3CannedACL.PublicRead,
            };

            var response = await client.PutObjectAsync(request);

            if (response.HttpStatusCode == HttpStatusCode.OK)
            {
                return("https://teller-uploads.s3.amazonaws.com/" + fileName);
            }
            else
            {
                return(null);
            }
        }
Example #5
0
        public async Task <string> AddFile(int projectId, int taskId, string fileName, MemoryStream ms)
        {
            string S3Key   = string.Format("{0}/{1}/{2}", projectId.ToString(), taskId.ToString(), fileName);
            var    request = new Amazon.S3.Model.PutObjectRequest();

            request.BucketName  = _bucketName;
            request.Key         = S3Key;
            request.InputStream = ms;
            await _s3Client.PutObjectAsync(request);

            var response = await _s3Client.PutACLAsync(new Amazon.S3.Model.PutACLRequest()
            {
                CannedACL  = S3CannedACL.PublicRead,
                BucketName = _bucketName,
                Key        = S3Key
            });

            var url = _s3Client.GetPreSignedURL(new Amazon.S3.Model.GetPreSignedUrlRequest()
            {
                BucketName = _bucketName,
                Key        = S3Key,
                Expires    = DateTime.Now.AddSeconds(604800)
            });

            return(url);
        }
Example #6
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (upload.PostedFile != null && upload.PostedFile.ContentLength > 0 && !string.IsNullOrEmpty(Request["awsid"]) && !string.IsNullOrEmpty(Request["awssecret"]) && !string.IsNullOrEmpty(this.bucket.Text))
            {
                var name = "s3readersample/" + ImageUploadHelper.Current.GenerateSafeImageName(upload.PostedFile.InputStream, upload.PostedFile.FileName);

                var client = new Amazon.S3.AmazonS3Client(Request["awsid"], Request["awssecret"], Amazon.RegionEndpoint.EUWest1);

                //For some reason we have to buffer the file in memory to prevent issues... Need to research further
                var ms = new MemoryStream();
                upload.PostedFile.InputStream.CopyTo(ms);
                ms.Seek(0, SeekOrigin.Begin);

                var request = new Amazon.S3.Model.PutObjectRequest()
                {
                    BucketName = this.bucket.Text, Key = name, InputStream = ms, CannedACL = Amazon.S3.S3CannedACL.PublicRead
                };


                var response = client.PutObject(request);
                if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
                {
                    result.Text = "Successfully uploaded " + name + "to bucket " + this.bucket.Text;
                }
                else
                {
                    result.Text = response.HttpStatusCode.ToString();
                }
            }
        }
        public async Task <string> GetImage(CreateEvent e)
        {
            //code for save imgae to s3 bucket
            string AWS_bucketName    = "softwareprojectnew2";
            string AWS_defaultFolder = "EventPicture";
            var    s3Client          = new AmazonS3Client(Amazon.RegionEndpoint.USEast1);

            var bucketName = AWS_bucketName;
            var keyName    = AWS_defaultFolder;

            keyName = keyName + "/" + e.ImageFile.FileName;
            e.Image = e.ImageFile.FileName;
            var fs      = e.ImageFile.OpenReadStream();
            var request = new Amazon.S3.Model.PutObjectRequest
            {
                BucketName  = bucketName,
                Key         = keyName,
                InputStream = fs,
                ContentType = e.ImageFile.ContentType,
                CannedACL   = S3CannedACL.PublicRead
            };
            await s3Client.PutObjectAsync(request);

            var path = string.Format("http://{0}.s3.amazonaws.com/{1}", bucketName, keyName);

            return(e.Image = Path.GetFileName(path));
        }
Example #8
0
        public static Response AmazonS3RequestStasher(NancyContext context)
        {
            if (context.Request.Method != "POST")
            {
                return(null);
            }

            object request_id_obj = null;

            if (!context.Items.TryGetValue("RequestId", out request_id_obj))
            {
                return(null);
            }
            string requestId = request_id_obj as string;

            var bucket = Environment.GetEnvironmentVariable("COMPUTE_STASH_S3_BUCKET");

            if (string.IsNullOrWhiteSpace(bucket))
            {
                Log.ForContext("RequestId", requestId)
                .Warning("COMPUTE_STASH_S3_BUCKET not set");
                return(null);
            }

            var aws_key                 = Environment.GetEnvironmentVariable("AWS_ACCESS_KEY");
            var aws_secret_key          = Environment.GetEnvironmentVariable("AWS_SECRET_ACCESS_KEY");
            var aws_region_endpoint_env = Env.GetEnvironmentString("AWS_REGION_ENDPOINT", "us-east-1");
            var aws_region_endpoint     = Amazon.RegionEndpoint.GetBySystemName(aws_region_endpoint_env);

            AmazonS3Client client = null;

            if (!string.IsNullOrWhiteSpace(aws_key) && !string.IsNullOrWhiteSpace(aws_secret_key))
            {
                client = new AmazonS3Client(aws_key, aws_secret_key, aws_region_endpoint);
            }
            else
            {
                client = new AmazonS3Client(aws_region_endpoint);
            }

            if (!_s3bucket_created)
            {
                var pbr = new Amazon.S3.Model.PutBucketRequest();
                pbr.BucketName      = bucket;
                pbr.UseClientRegion = true;
                client.PutBucket(pbr);
                _s3bucket_created = true;
            }

            var por = new Amazon.S3.Model.PutObjectRequest();

            por.Key         = requestId;
            por.BucketName  = bucket;
            por.ContentBody = GetRequestJson(context);
            client.PutObjectAsync(por).ContinueWith(c => {
                Log.Information("Stashed request to {RequestId}", requestId);
            });

            return(null);
        }
Example #9
0
        protected async Task <string> UploadFileToAWSAsync(IFormFile myfile, string subFolder = "")
        {
            var result = "";

            try
            {
                var s3Client   = new AmazonS3Client(_AwsAccessKeyId, _AwsSecretAccesKey, RegionEndpoint.USEast1);
                var bucketName = AWS_bucketName;
                var keyName    = AWS_defaultFolder;
                if (!string.IsNullOrEmpty(subFolder))
                {
                    keyName = keyName + "/" + subFolder.Trim();
                }
                keyName = keyName + "/" + myfile.FileName;

                var fs      = myfile.OpenReadStream();
                var request = new Amazon.S3.Model.PutObjectRequest
                {
                    BucketName  = bucketName,
                    Key         = keyName,
                    InputStream = fs,
                    ContentType = myfile.ContentType,
                    CannedACL   = S3CannedACL.PublicRead
                };
                await s3Client.PutObjectAsync(request);

                result = string.Format("http://{0}.s3.amazonaws.com/{1}", bucketName, keyName);
            }
            catch (Exception ex)
            {
                result = ex.Message;
            }
            return(result);
        }
Example #10
0
 /// <summary>
 /// Загружает файл на сервер
 /// </summary>
 /// <param name="filename">Путь к файлу на диске</param>
 /// <param name="path">Путь к файлу на сервере</param>
 public void Upload(string filename, string path)
 {
     try
     {
         var request = new Amazon.S3.Model.PutObjectRequest()
         {
             BucketName = _bucketName,
             Key        = path,
             FilePath   = filename,
             Timeout    = _timeout,
         };
         request.AddHeader("x-amz-acl", "public-read");
         _client.PutObject(request);
     }
     catch (ThreadAbortException tae)
     {
     }
     catch (Exception ex)
     {
         throw new ApplicationException("Не удалось загрузить файл на сервер.", ex);
     }
     finally
     {
     }
 }
        public void UploadFile(Uri fileUrl, Stream s)
        {
            var filePath = fileUrl.AbsolutePath;
            // We need to strip off any leading '/' in the path or
            // else it creates a path with an empty leading segment
            if (filePath.StartsWith("/"))
                filePath = filePath.Substring(1);

            var s3 = new Amazon.S3.AmazonS3Client(
                    AccessKeyId, SecretAccessKey, RegionEndpoint);

            var s3Requ = new Amazon.S3.Model.PutObjectRequest
            {
                BucketName = BucketName,
                Key = filePath,
                InputStream = s,
                AutoCloseStream = false,
            };
            var s3Resp = s3.PutObject(s3Requ);

            if (DnsProvider != null)
            {
                var hostname = fileUrl.Host;
                DnsProvider.EditCnameRecord(hostname, DnsCnameTarget);
            }
            else
            {
                // TODO:  do nothing for now
                // Throw Exception???
            }
        }
Example #12
0
        /// <summary>
        /// Загружает данные из потока на сервер
        /// </summary>
        /// <param name="data">Поток данных</param>
        /// <param name="path">Путь к файлу на сервере</param>
        public void Upload(Stream data, string path)
        {
            try
            {
                var request = new Amazon.S3.Model.PutObjectRequest()
                {
                    BucketName = _bucketName,
                    Key = path,
                    InputStream = data,
                    Timeout = _timeout,
                };
                request.AddHeader("x-amz-acl", "public-read");
                _client.PutObject(request);
            }
            catch (ThreadAbortException tae)
            {

            }
            catch (Exception ex)
            {
                throw new ApplicationException("Не удалось загрузить файл на сервер.", ex);
            }
            finally
            {

            }
        }
Example #13
0
        public async Task <bool> UploadFileAsync(string fileName, Stream storageStream)
        {
            if (string.IsNullOrEmpty(fileName))
            {
                throw new ArgumentException("File name must be specified.");
            }

            var fileTransferUtility =
                new TransferUtility(_s3Client);

            using (var client = new AmazonS3Client(bucketRegion))
            {
                if (storageStream.Length > 0)
                {
                    if (storageStream.CanSeek)
                    {
                        storageStream.Seek(0, SeekOrigin.Begin);
                    }
                }

                var request = new PutObjectRequest
                {
                    AutoCloseStream = true,
                    BucketName      = bucketName,
                    InputStream     = storageStream,
                    Key             = fileName
                };
                var response = await client.PutObjectAsync(request).ConfigureAwait(false);

                return(response.HttpStatusCode == HttpStatusCode.OK);
            }
        }
Example #14
0
        public ActionResult BulkCreateConfirmed(string prefix = "", int maxKeys = 100)
        {
            ViewBag.prefix = prefix;
              ViewBag.maxKeys = maxKeys;

              byte[] buffer = new byte[4096];

              if (Request.Files.Count > 0)
              {
            try
            {
              using (var fileStream = Request.Files[0].InputStream)
              {
            ZipFile zf = new ZipFile(fileStream);

            foreach (ZipEntry zipEntry in zf)
            {
              if (!zipEntry.IsFile)
              {
                continue;
              }

              string entryFileName = zipEntry.Name;
              string entryKey = prefix + entryFileName;

              using (MemoryStream ms = new MemoryStream((int)zipEntry.Size))
              {
                ICSharpCode.SharpZipLib.Core.StreamUtils.Copy(zf.GetInputStream(zipEntry), ms, buffer);

                ms.Seek(0, SeekOrigin.Begin);

                var put = new Amazon.S3.Model.PutObjectRequest();
                put.WithBucketName(WebConfigurationManager.AppSettings["UploadBucket"]);
                put.WithCannedACL(Amazon.S3.Model.S3CannedACL.PublicRead);

                put.WithKey(entryKey);
                put.WithInputStream(ms);
                Amazon.S3.Model.PutObjectResponse result = s3.PutObject(put);

              }

            }
              }

              return RedirectToAction("Index", new { prefix = prefix, maxKeys = maxKeys });
            }
            catch (Exception ex)
            {
              Request.RequestContext.HttpContext.Trace.Write(ex.Message);
            }
              }

              return View();
        }
Example #15
0
        private async Task Upload(string objectKey, MemoryStream stream, Amazon.S3.IAmazonS3 client)
        {
            var request = new Amazon.S3.Model.PutObjectRequest()
            {
                BucketName  = _config.BucketName,
                Key         = objectKey,
                InputStream = stream,
                ServerSideEncryptionMethod = Amazon.S3.ServerSideEncryptionMethod.AES256
            };

            var response = await client.PutObjectAsync(request);
        }
Example #16
0
 private string _UploadToS3(string path)
 {
     Amazon.S3.Model.PutObjectRequest s3PutRequest = new Amazon.S3.Model.PutObjectRequest();
     s3PutRequest = new Amazon.S3.Model.PutObjectRequest
     {
         BucketName = _Config.AWSS3Bucket,
         CannedACL  = S3CannedACL.PublicRead,
         Key        = Guid.NewGuid().ToString(),
         FilePath   = path
     };
     _S3Client.PutObjectAsync(s3PutRequest);
     return($"https://s3.amazonaws.com/{s3PutRequest.BucketName}/{s3PutRequest.Key}");
 }
Example #17
0
        private void InternalCreateContainer(string containerName)
        {
            using (var emptyStream = new MemoryStream(new byte[0]))
            {
                var folderRequest = new Amazon.S3.Model.PutObjectRequest()
                {
                    BucketName  = ContentStorageBucketName,
                    Key         = containerName + "/",
                    InputStream = emptyStream
                };

                var folderResponse = _amazonS3.PutObjectAsync(folderRequest).Result;
            }
        }
Example #18
0
        public async Task <string> StoreImage(string name, byte[] content, string mimeType, CancellationToken cancellationToken)
        {
            var client  = GetClient();
            var request = new Amazon.S3.Model.PutObjectRequest();

            request.BucketName  = _bucketName;
            request.ContentType = mimeType;
            request.InputStream = new MemoryStream(content);
            request.Key         = name;
            request.CannedACL   = "public-read";
            var response = await client.PutObjectAsync(request, cancellationToken);

            return(name);
        }
Example #19
0
        public async Task <string> StoreTextFile(string name, string content, CancellationToken cancellationToken)
        {
            var client  = GetClient();
            var request = new Amazon.S3.Model.PutObjectRequest();

            request.BucketName  = _bucketName;
            request.ContentType = "";
            request.ContentBody = content;
            request.Key         = name;
            request.CannedACL   = "private ";
            var response = await client.PutObjectAsync(request, cancellationToken);

            return(name);
        }
Example #20
0
        public async System.Threading.Tasks.Task UploadFile(string filePath, string s3Bucket, string newFileName, bool deleteLocalFileOnSuccess, IFormFile fileUploaded)
        {
            //save in s3
            Amazon.S3.Model.PutObjectRequest s3PutRequest = new Amazon.S3.Model.PutObjectRequest();
            s3PutRequest = new Amazon.S3.Model.PutObjectRequest();

            using (var ms = new MemoryStream())
            {
                fileUploaded.CopyTo(ms);
                var    fileBytes = ms.ToArray();
                string s         = Convert.ToBase64String(fileBytes);
                s3PutRequest.InputStream = ms;
                var parsedContentDisposition = ContentDispositionHeaderValue.Parse(fileUploaded.ContentDisposition);
                //document.Name = parsedContentDisposition.FileName.TrimStart('\"').TrimEnd('\"');
            }



            //s3PutRequest.FilePath = filePath;
            s3PutRequest.BucketName = s3Bucket;
            s3PutRequest.CannedACL  = Amazon.S3.S3CannedACL.PublicRead;

            //key - new file name
            if (!string.IsNullOrWhiteSpace(newFileName))
            {
                s3PutRequest.Key = newFileName;
            }

            s3PutRequest.Headers.ExpiresUtc = new DateTime(2020, 1, 1);

            try
            {
                Amazon.S3.Model.PutObjectResponse s3PutResponse = await this.S3Client.PutObjectAsync(s3PutRequest);

                if (deleteLocalFileOnSuccess)
                {
                    ////Delete local file
                    //if (System.IO.File.Exists(filePath))
                    //{
                    //    System.IO.File.Delete(filePath);
                    //}
                }
            }
            catch (Exception ex)
            {
                //handle exceptions
            }
        }
Example #21
0
        static Task <Amazon.S3.Model.PutObjectResponse> UploadToS3(CompatibilitySummary summary)
        {
            var awsAccessKey = Environment.GetEnvironmentVariable("ps_aws_access_key");
            var awsSecretKey = Environment.GetEnvironmentVariable("ps_aws_secret_key");
            var creds        = new Amazon.Runtime.BasicAWSCredentials(awsAccessKey, awsSecretKey);
            var client       = new AmazonS3Client(creds, Amazon.RegionEndpoint.USWest2);
            var summaryBody  = JsonConvert.SerializeObject(summary);
            var putRequest   = new Amazon.S3.Model.PutObjectRequest
            {
                BucketName  = "playcompatibility",
                Key         = "compat_summary.json",
                ContentBody = summaryBody
            };

            return(client.PutObjectAsync(putRequest));
        }
        public async Task PutPayload(string BucketName, string FileKey, string JsonPayload)
        {
            IAmazonS3 S3Client = new AmazonS3Client("AKIAIAYIN7WKAGAFBTDA", "zxa+XMi4ORN8sk5cXsqEozq2Q1Wcwac1xOPrkwyB", "EUWest1");

            using (var memoryStream = new MemoryStream())
            {
                using (var jsondocument = new StreamWriter(JsonPayload))
                {
                    Amazon.S3.Model.PutObjectRequest pr = new Amazon.S3.Model.PutObjectRequest();
                    pr.BucketName  = BucketName;
                    pr.Key         = FileKey;
                    pr.InputStream = jsondocument.BaseStream;
                    var x = await S3Client.PutObjectAsync(pr);
                }
            }
        }
Example #23
0
        private void UpdateInstances(List <string> instances)
        {
            Amazon.S3.Model.PutObjectResponse rsp;
            IAWSContext ctx     = AppUtility.GetContext();
            var         name    = AppUtility.GetContext().Bucket;
            var         key     = "floor";
            var         request = new Amazon.S3.Model.PutObjectRequest();

            request.WithBucketName(name);
            request.WithKey("instances");
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(instances);

            request.WithContentBody(json);
            using (var client = ctx.GetS3Client())
            {
                rsp = client.PutObject(request);
            }
        }
Example #24
0
        public override async Task <string> HandleEvent(
            APIGatewayProxyRequest request,
            ILambdaContext context,
            string deliveryId,
            BaseEvent eventPayload)
        {
            var client           = new Amazon.S3.AmazonS3Client();
            var putObjectRequest = new Amazon.S3.Model.PutObjectRequest
            {
                BucketName  = bucketName,
                Key         = deliveryId,
                ContentBody = request.Body
            };

            await client.PutObjectAsync(putObjectRequest);

            return($"Event payload uploaded to {bucketName}/{deliveryId}");
        }
Example #25
0
        public async Task EditFile(string filePath, string contentType, string content)
        {
#pragma warning disable 618 // "'StoredProfileCredentials' is obsolete..."
            var creds = new StoredProfileAWSCredentials("acmesharp-tests");
#pragma warning restore 618
            var reg    = RegionEndpoint.GetBySystemName(AwsRegion);
            var delete = content == null;

            // We need to strip off any leading '/' in the path or
            // else it creates a path with an empty leading segment
            // if (filePath.StartsWith("/"))
            //     filePath = filePath.Substring(1);
            filePath = filePath.Trim('/');

            using (var s3 = new Amazon.S3.AmazonS3Client(creds, reg))
            {
                if (delete)
                {
                    var s3Requ = new Amazon.S3.Model.DeleteObjectRequest
                    {
                        BucketName = BucketName,
                        Key        = filePath,
                    };
                    var s3Resp = await s3.DeleteObjectAsync(s3Requ);
                }
                else
                {
                    using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(content)))
                    {
                        var s3Requ = new Amazon.S3.Model.PutObjectRequest
                        {
                            BucketName  = BucketName,
                            Key         = filePath,
                            ContentType = contentType,
                            InputStream = ms,
                            CannedACL   = S3CannedAcl,
                        };

                        var s3Resp = await s3.PutObjectAsync(s3Requ);
                    }
                }
            }
        }
Example #26
0
        public void UploadFile(bool deleteLocalFileOnSuccess, Tuple <string, string> pathScreenshot, string campaign, string userName, string userLastName, string platform)
        {
            // PATH A RECUPERER
            if (pathScreenshot.Item1.Contains("LARGE"))
            {
                screenType = "Large";
            }
            else
            {
                screenType = "Simple";
            }
            string s3Bucket = bucket + "/" + _hndlr.GetStringSha256Hash(userName + userLastName) + "/" + _hndlr.GetStringSha256Hash(campaign) + "/" + platform + "/" + screenType;

            //sauvegarde S3
            Amazon.S3.Model.PutObjectRequest s3PutRequest = new Amazon.S3.Model.PutObjectRequest();
            s3PutRequest            = new Amazon.S3.Model.PutObjectRequest();
            s3PutRequest.FilePath   = pathScreenshot.Item1;
            s3PutRequest.BucketName = s3Bucket;
            s3PutRequest.CannedACL  = S3CannedACL.PublicRead;
            //Clef - nouveau nom de fichier
            if (!string.IsNullOrWhiteSpace(pathScreenshot.Item1))
            {
                s3PutRequest.Key = pathScreenshot.Item2;
            }
            s3PutRequest.Headers.Expires = new DateTime(2020, 1, 1);
            try
            {
                Amazon.S3.Model.PutObjectResponse s3PutResponse = this.S3Client.PutObject(s3PutRequest);
                if (deleteLocalFileOnSuccess)
                {
                    //Delete local file
                    if (File.Exists(pathScreenshot.Item2))
                    {
                        File.Delete(pathScreenshot.Item2);
                    }
                }
            }
            catch (Exception ex)
            {
                //handle exceptions
            }
        }
        public void WriteFileBegin(string strPath, System.IO.Stream oStream, AsyncCallback cb, object oParam)
        {
            try
            {
                m_oWriteFile = new TransportClass(cb, oParam);
                m_oWriteFile.m_nReadWriteBytes = (int)oStream.Length;
                m_oWriteFile.m_oS3Client       = Amazon.AWSClientFactory.CreateAmazonS3Client(m_oRegion);

                string strFileKey = GetFilePath(strPath);
                Amazon.S3.Model.PutObjectRequest oRequest = new Amazon.S3.Model.PutObjectRequest()
                                                            .WithBucketName(m_strBucketName).WithKey(strFileKey);
                oRequest.WithInputStream(oStream);

                m_oWriteFile.m_oS3Client.BeginPutObject(oRequest, m_oWriteFile.m_fCallback, m_oWriteFile.m_oParam);
            }
            catch
            {
                m_oWriteFile.m_eError = ErrorTypes.StorageWrite;
                m_oWriteFile.DisposeAndCallback();
            }
        }
Example #28
0
 public async Task<string> AddFile(int projectId, int taskId, string fileName, MemoryStream ms)
 {
     string S3Key = string.Format("{0}/{1}/{2}", projectId.ToString(), taskId.ToString(), fileName);
     var request = new Amazon.S3.Model.PutObjectRequest();
     request.BucketName = _bucketName;
     request.Key = S3Key;
     request.InputStream = ms;
     await _s3Client.PutObjectAsync(request);
     var response = await _s3Client.PutACLAsync(new Amazon.S3.Model.PutACLRequest()
     {
         CannedACL = S3CannedACL.PublicRead,
         BucketName = _bucketName,
         Key = S3Key
     });
     var url = _s3Client.GetPreSignedURL(new Amazon.S3.Model.GetPreSignedUrlRequest()
     {
         BucketName = _bucketName,
         Key = S3Key,
         Expires = DateTime.Now.AddSeconds(604800)
     });
     return url;
 }
Example #29
0
        /// <summary>
        /// Uploads a file to s3.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="fileBytes">The file bytes.</param>
        /// <param name="contentType">Type of the content.</param>
        public void UploadFileToS3(string key, byte[] fileBytes, string contentType, Guid fileUUID)
        {
            //http://docs.aws.amazon.com/AmazonS3/latest/dev/UploadObjSingleOpNET.html
            //http://stackoverflow.com/questions/18635963/asp-net-uploading-a-file-to-amazon-s3

            var stream = new System.IO.MemoryStream(fileBytes);

            stream.Position = 0;

            var putRequest1 = new Amazon.S3.Model.PutObjectRequest
            {
                BucketName  = s3Settings.BucketName,
                Key         = key,
                InputStream = stream,
                ContentType = contentType,
                CannedACL   = new Amazon.S3.S3CannedACL(s3Settings.DefaultUploadAcl),
                ServerSideEncryptionMethod = Amazon.S3.ServerSideEncryptionMethod.None
            };

            // DEVELOPER NOTE: this this function with appfile.js file
            putRequest1.Metadata.Add("uuid", fileUUID.ToString("N"));
            Amazon.S3.Model.PutObjectResponse response1 = s3Client.PutObject(putRequest1);
        }
        public ErrorTypes CreateDirectory(string strPath)
        {
            ErrorTypes eResult = ErrorTypes.StorageCreateDir;

            try
            {
                string strDirKey = GetDirPath(strPath);
                using (Amazon.S3.AmazonS3 oS3Client = Amazon.AWSClientFactory.CreateAmazonS3Client(m_oRegion))
                {
                    Amazon.S3.Model.PutObjectRequest oRequest = new Amazon.S3.Model.PutObjectRequest();
                    oRequest.WithBucketName(m_strBucketName).WithKey(strDirKey).WithContentBody(string.Empty);

                    using (Amazon.S3.Model.PutObjectResponse oResponse = oS3Client.PutObject(oRequest))
                    {
                        eResult = ErrorTypes.NoError;
                    }
                }
            }
            catch
            {
            }
            return(eResult);
        }
        public void UploadStream(string bucketName, System.IO.Stream stream, string serverPath, int?cacheControlMaxAgeSeconds = null)
        {
            //ref: http://docs.aws.amazon.com/AmazonS3/latest/dev/UploadObjSingleOpNET.html

            var region = Amazon.RegionEndpoint.GetBySystemName(this.Credential.Region);

            using (var client = new Amazon.S3.AmazonS3Client(this.Credential.AcesssKey, this.Credential.SecretKey, region))
            {
                var putRequest2 = new Amazon.S3.Model.PutObjectRequest
                {
                    BucketName  = bucketName,
                    Key         = serverPath,
                    InputStream = stream
                };

                if (cacheControlMaxAgeSeconds.HasValue)
                {
                    putRequest2.Headers.CacheControl = string.Format("max-age={0}, public", cacheControlMaxAgeSeconds);
                }

                var response2 = client.PutObject(putRequest2);
            }
        }
Example #32
0
        public async System.Threading.Tasks.Task UploadFileAsync(string filePath, string s3Bucket, string newFileName, bool deleteLocalFileOnSuccess, byte[] renderedBytes)
        {
            //save in s3
            Amazon.S3.Model.PutObjectRequest s3PutRequest = new Amazon.S3.Model.PutObjectRequest();
            s3PutRequest = new Amazon.S3.Model.PutObjectRequest();

            s3PutRequest.InputStream = new MemoryStream(renderedBytes);
            //s3PutRequest.FilePath = filePath;
            s3PutRequest.BucketName = s3Bucket;
            s3PutRequest.CannedACL  = Amazon.S3.S3CannedACL.PublicRead;

            //key - new file name
            if (!string.IsNullOrWhiteSpace(newFileName))
            {
                s3PutRequest.Key = newFileName;
            }

            s3PutRequest.Headers.ExpiresUtc = new DateTime(2025, 1, 1);

            try
            {
                Amazon.S3.Model.PutObjectResponse s3PutResponse = await this.S3Client.PutObjectAsync(s3PutRequest);

                if (deleteLocalFileOnSuccess)
                {
                    ////Delete local file
                    //if (System.IO.File.Exists(filePath))
                    //{
                    //    System.IO.File.Delete(filePath);
                    //}
                }
            }
            catch (Exception ex)
            {
                //handle exceptions
            }
        }
Example #33
0
        public void UploadFile(string filePath, string newFileName, string s3Bucket = null, bool deleteLocalFileOnSuccess = true)
        {
            //save in s3
            Amazon.S3.Model.PutObjectRequest s3PutRequest = new Amazon.S3.Model.PutObjectRequest();
            s3PutRequest            = new Amazon.S3.Model.PutObjectRequest();
            s3PutRequest.FilePath   = filePath;
            s3PutRequest.BucketName = (s3Bucket != null) ? s3Bucket : FileService.s3Bucket;
            s3PutRequest.CannedACL  = Amazon.S3.S3CannedACL.PublicRead;

            //key - new file name
            if (!string.IsNullOrWhiteSpace(newFileName))
            {
                s3PutRequest.Key = newFileName;
            }

            s3PutRequest.Headers.Expires = new DateTime(2020, 1, 1);

            try
            {
                Amazon.S3.Model.PutObjectResponse s3PutResponse = this.S3Client.PutObject(s3PutRequest);

                if (deleteLocalFileOnSuccess)
                {
                    //Delete local file
                    if (System.IO.File.Exists(filePath))
                    {
                        System.IO.File.Delete(filePath);
                    }
                }
            }
            catch (Exception ex)
            {
                Exception exp = ex;
                //handle exceptions
            }
        }
        public ErrorTypes WriteFile(string strPath, System.IO.Stream oStream, out int nReadWriteBytes)
        {
            ErrorTypes eResult = ErrorTypes.StorageWrite;
            nReadWriteBytes = (int)oStream.Length;
            try
            {
                string strFileKey = GetFilePath(strPath);
                using (Amazon.S3.AmazonS3 oS3Client = Amazon.AWSClientFactory.CreateAmazonS3Client(m_oRegion))
                {
                    Amazon.S3.Model.PutObjectRequest oRequest = new Amazon.S3.Model.PutObjectRequest();
                    oRequest.WithBucketName(m_strBucketName).WithKey(strFileKey).WithInputStream(oStream);

                    using (Amazon.S3.Model.PutObjectResponse oResponse = oS3Client.PutObject(oRequest))
                    {
                        oResponse.Dispose();
                    }
                }
            }
            catch
            {
                nReadWriteBytes = 0;
            }

            return eResult;
        }
        public ErrorTypes CreateDirectory(string strPath)
        {
            ErrorTypes eResult = ErrorTypes.StorageCreateDir;
            try
            {
                string strDirKey = GetDirPath(strPath);
                using (Amazon.S3.AmazonS3 oS3Client = Amazon.AWSClientFactory.CreateAmazonS3Client(m_oRegion))
                {
                    Amazon.S3.Model.PutObjectRequest oRequest = new Amazon.S3.Model.PutObjectRequest();
                    oRequest.WithBucketName(m_strBucketName).WithKey(strDirKey).WithContentBody(string.Empty);

                    using (Amazon.S3.Model.PutObjectResponse oResponse = oS3Client.PutObject(oRequest))
                    {
                        eResult = ErrorTypes.NoError;
                    }
                }
            }
            catch
            {
            }
            return eResult;
        }
Example #36
0
        public string StoreFile(Stream stream, string contentType)
        {
            string key = Guid.NewGuid().ToString("N") + "." + contentType.Split('/').LastOrDefault();

            Amazon.S3.Model.PutObjectRequest por = new Amazon.S3.Model.PutObjectRequest();
            por.WithBucketName(Helper.AppConfig.AWS_Bucket)
                .WithKey(key)
                .WithTimeout(3600000)
                .WithContentType(contentType)
                .WithStorageClass(Amazon.S3.Model.S3StorageClass.ReducedRedundancy)
                .WithCannedACL(Amazon.S3.Model.S3CannedACL.PublicRead)
                .WithInputStream(stream);

            Amazon.S3.Model.PutObjectResponse response = S3Helper.S3ClientInstance.PutObject(por);

            return key;
        }
        public void DeployPush(string appName, string s3Location, string sourcePath)
        {
            var s3 = new S3LocationParser(s3Location);

            using (var s3Client = new Amazon.S3.AmazonS3Client(Credentials, Amazon.RegionEndpoint.USEast1))
            {
                var getRequest = new Amazon.S3.Model.GetObjectMetadataRequest
                {
                    BucketName = s3.BucketName,
                    Key = s3.Key
                };

                try
                {
                    var getResponse = s3Client.GetObjectMetadata(getRequest);

                    // If we got this far, the file already exists in the S3 bucket, so get out!
                    throw new S3KeyAlreadyExistsException(s3);
                }
                catch (AmazonS3Exception ex)
                {
                    // If we got this far, then it's because the S3 file doesn't exist.
                    // Therefore, it's OK to upload with this key.
                    var zipFileName = s3.FileName;
                    var g = Guid.NewGuid().ToString();
                    var outputFile = Path.Combine(Path.GetTempPath(), g + ".tmp");
                    ZipFile.CreateFromDirectory(sourcePath, outputFile);
                    var zipFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), zipFileName);

                    if (File.Exists(zipFile))
                        File.Delete(zipFile);

                    File.Move(outputFile, zipFile);

                    var putRequest = new Amazon.S3.Model.PutObjectRequest
                    {
                        BucketName = s3.BucketName,
                        FilePath = zipFile,
                        Key = s3.Key
                    };

                    var putResponse = s3Client.PutObject(putRequest);

                    using (var cdClient = new Amazon.CodeDeploy.AmazonCodeDeployClient(Credentials, Amazon.RegionEndpoint.USEast1))
                    {
                        var revLocation = new Amazon.CodeDeploy.Model.RevisionLocation
                        {
                            RevisionType = Amazon.CodeDeploy.RevisionLocationType.S3,
                            S3Location = new Amazon.CodeDeploy.Model.S3Location
                                            {
                                                Bucket = s3.BucketName,
                                                BundleType = Amazon.CodeDeploy.BundleType.Zip,
                                                Key = s3.Key
                                            }
                        };

                        var regRequest = new Amazon.CodeDeploy.Model.RegisterApplicationRevisionRequest
                        {
                            ApplicationName = appName,
                            Revision = revLocation
                        };

                        var regResponse = cdClient.RegisterApplicationRevision(regRequest);

                        var x = 0;
                    }
                }
            }
        }
        /// <summary>
        /// Uploads the drawing to Amazon S3
        /// </summary>
        /// <param name="dwgFilePath"></param>
        /// <returns>Presigned Url of the uploaded drawing file in Amazon S3</returns>
        public static String UploadDrawingToS3(String dwgFilePath)
        {
            String s3URL = String.Empty;

            try
            {
                if (!System.IO.File.Exists(dwgFilePath))
                {
                    return(s3URL);
                }

                String keyName = System.IO.Path.GetFileName(dwgFilePath);

                //be sure to connect to the endpoint which is the same region of your bucket!
                using (Amazon.S3.IAmazonS3 client = new Amazon.S3.AmazonS3Client(Amazon.RegionEndpoint.USWest2))
                {
                    Amazon.S3.Model.PutObjectRequest putRequest1 = new Amazon.S3.Model.PutObjectRequest
                    {
                        BucketName  = S3BucketName,
                        Key         = keyName,
                        ContentBody = "sample text"
                    };

                    Amazon.S3.Model.PutObjectResponse response1 = client.PutObject(putRequest1);

                    Amazon.S3.Model.PutObjectRequest putRequest2 = new Amazon.S3.Model.PutObjectRequest
                    {
                        BucketName  = S3BucketName,
                        Key         = keyName,
                        FilePath    = dwgFilePath,
                        ContentType = "application/acad"
                    };
                    putRequest2.Metadata.Add("x-amz-meta-title", keyName);

                    Amazon.S3.Model.PutObjectResponse response2 = client.PutObject(putRequest2);

                    Amazon.S3.Model.GetPreSignedUrlRequest request1 = new Amazon.S3.Model.GetPreSignedUrlRequest
                    {
                        BucketName = S3BucketName,
                        Key        = keyName,
                        Expires    = DateTime.Now.AddMinutes(5)
                    };

                    s3URL = client.GetPreSignedURL(request1);

                    Console.WriteLine(s3URL);
                }
            }
            catch (Amazon.S3.AmazonS3Exception amazonS3Exception)
            {
                if (amazonS3Exception.ErrorCode != null &&
                    (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") ||
                     amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
                {
                    Console.WriteLine("Check the provided AWS Credentials.");
                    Console.WriteLine("For service sign up go to http://aws.amazon.com/s3");
                }
                else
                {
                    Console.WriteLine("Error occurred. Message:'{0}' when writing an object", amazonS3Exception.Message);
                }
            }
            return(s3URL);
        }
        public void WriteFileBegin(string strPath, System.IO.Stream oStream, AsyncCallback cb, object oParam)
        {
            try
            {
                m_oWriteFile = new TransportClass(cb, oParam);
                m_oWriteFile.m_nReadWriteBytes = (int)oStream.Length;
                m_oWriteFile.m_oS3Client = Amazon.AWSClientFactory.CreateAmazonS3Client(m_oRegion);

                string strFileKey = GetFilePath(strPath);
                Amazon.S3.Model.PutObjectRequest oRequest = new Amazon.S3.Model.PutObjectRequest()
                    .WithBucketName(m_strBucketName).WithKey(strFileKey);
                oRequest.WithInputStream(oStream);

                m_oWriteFile.m_oS3Client.BeginPutObject(oRequest, m_oWriteFile.m_fCallback, m_oWriteFile.m_oParam);
            }
            catch
            {
                m_oWriteFile.m_eError = ErrorTypes.StorageWrite;
                m_oWriteFile.DisposeAndCallback();
            }
        }
        /// <summary>
        /// Uploads the drawing to Amazon S3
        /// </summary>
        /// <param name="dwgFilePath"></param>
        /// <returns>Presigned Url of the uploaded drawing file in Amazon S3</returns>
        public static String UploadDrawingToS3(String dwgFilePath)
        {
            String s3URL = String.Empty;

            try
            {
                if (!System.IO.File.Exists(dwgFilePath))
                    return s3URL;

                String keyName = System.IO.Path.GetFileName(dwgFilePath);

                using (Amazon.S3.IAmazonS3 client = new Amazon.S3.AmazonS3Client(Amazon.RegionEndpoint.APSoutheast1))
                {
                    Amazon.S3.Model.PutObjectRequest putRequest1 = new Amazon.S3.Model.PutObjectRequest
                    {
                        BucketName = S3BucketName,
                        Key = keyName,
                        ContentBody = "sample text"
                    };

                    Amazon.S3.Model.PutObjectResponse response1 = client.PutObject(putRequest1);

                    Amazon.S3.Model.PutObjectRequest putRequest2 = new Amazon.S3.Model.PutObjectRequest
                    {
                        BucketName = S3BucketName,
                        Key = keyName,
                        FilePath = dwgFilePath,
                        ContentType = "application/acad"
                    };
                    putRequest2.Metadata.Add("x-amz-meta-title", keyName);

                    Amazon.S3.Model.PutObjectResponse response2 = client.PutObject(putRequest2);

                    Amazon.S3.Model.GetPreSignedUrlRequest request1 = new Amazon.S3.Model.GetPreSignedUrlRequest
                    {
                        BucketName = S3BucketName,
                        Key = keyName,
                        Expires = DateTime.Now.AddMinutes(5)
                    };

                    s3URL = client.GetPreSignedURL(request1);

                    Console.WriteLine(s3URL);
                }
            }
            catch (Amazon.S3.AmazonS3Exception amazonS3Exception)
            {
                if (amazonS3Exception.ErrorCode != null &&
                    (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") ||
                    amazonS3Exception.ErrorCode.Equals("InvalidSecurity")))
                {
                    Console.WriteLine("Check the provided AWS Credentials.");
                    Console.WriteLine("For service sign up go to http://aws.amazon.com/s3");
                }
                else
                {
                    Console.WriteLine("Error occurred. Message:'{0}' when writing an object", amazonS3Exception.Message);
                }
            }
            return s3URL;
        }
Example #41
0
        /// <summary>
        /// Put an object to an S3 bucket
        /// from a stream.
        /// </summary>
        /// <param name="bucket">The name of the bucket to upload to.</param>
        /// <param name="key">The key to store the object as on S3.</param>
        /// <param name="stream">The stream representing the file data.</param>
        /// <param name="storageClass">The Amazon.S3.S3StorageClass for the file (default standard)</param>
        /// <returns></returns>
        public static Amazon.S3.Model.PutObjectResponse PutObjectResponse(string bucket, string key, Stream stream, Amazon.S3.S3StorageClass storageClass = null)
        {
            Amazon.S3.Model.PutObjectResponse response = new Amazon.S3.Model.PutObjectResponse();
            using (Amazon.S3.IAmazonS3 client = new Factory().S3Client())
            {
                Amazon.S3.Model.PutObjectRequest request = new Amazon.S3.Model.PutObjectRequest()
                {
                    BucketName = bucket,
                    Key = key,
                    StorageClass = (storageClass == null ? Amazon.S3.S3StorageClass.Standard : storageClass),
                    InputStream = stream
                };

                response = client.PutObject(request);
            }
            return response;
        }
        public ActionResult Edit(TimelineEvent timelineEvent)
        {
            try
            {
                var file = Request.Files["file"];

                if (file != null && file.FileName.EndsWith(".png") || file.FileName.EndsWith(".jpg"))
                {
                    var fullPath = Server.MapPath("/" + file.FileName);
                    file.SaveAs(fullPath);

                    var config = new Amazon.S3.AmazonS3Config {
                        MaxErrorRetry = 0
                    };
                    var client = new Amazon.S3.AmazonS3Client("AKIAJTSDXO36LAHQEOJA", "+HW/vJzJ+XApMYhBzVtAYElxiEZIVw24NXTYBtiG", config);

                    var req = new Amazon.S3.Model.PutObjectRequest {
                        BucketName = "10years-dawitisaak",
                        FilePath = fullPath
                    };
                    var res = client.PutObject(req);

                    timelineEvent.Image = res.AmazonId2;
                }

                // TODO: Add update logic here
                timelineEvent = timelineService.Save(timelineEvent);

                return RedirectToAction("Details", new { id = timelineEvent.Id });
            }
            catch(Exception ex)
            {
                throw ex;
                ModelState.AddModelError("Could not Edit", ex);
                return View(timelineEvent);
            }
        }
Example #43
0
        public ActionResult Edit(S3Object s3object, string prefix = "", int maxKeys = 100)
        {
            ViewBag.prefix = prefix;
              ViewBag.maxKeys = maxKeys;

              if (ModelState.IsValid && Request.Files.Count > 0)
              {
            var put = new Amazon.S3.Model.PutObjectRequest();
            put.WithBucketName(WebConfigurationManager.AppSettings["UploadBucket"]);
            put.WithKey(s3object.Key);

            var file = Request.Files[0];
            put.WithContentType(file.ContentType);
            put.WithInputStream(file.InputStream);
            put.WithCannedACL(Amazon.S3.Model.S3CannedACL.PublicRead);
            s3.PutObject(put);

            return RedirectToAction("Index", new { prefix = prefix, maxKeys = maxKeys });
              }

              return View(s3object);
        }
        public void Insert(string key, T value, TimeSpan expiration)
        {
            if (value != null)
            {
                long expirationTime = (expiration == TimeSpan.Zero) ? 0 : DateTime.UtcNow.Add(expiration).Ticks;
                long creationTime   = DateTime.UtcNow.Ticks;

                //Dictionary<string, string> meta = new Dictionary<string, string>();

                try
                {
                    using (var ms = new System.IO.MemoryStream())
                    {
                        using (StreamWriter sw = new StreamWriter(ms))
                        {
                            using (JsonWriter writer = new JsonTextWriter(sw))
                            {
                                if (value is byte[])
                                {
                                    byte[] bvalue = value as byte[];
                                    ms.Write(bvalue, 0, bvalue.Length);
                                }
                                else
                                {
                                    //json serialization
                                    serializer.Serialize(writer, value);
                                }
                                writer.Flush();
                                ms.Seek(0, SeekOrigin.Begin);
                                //lock (_lockconnections)
                                //{
                                var putObj = new Amazon.S3.Model.PutObjectRequest()
                                {
                                    BucketName      = this.Bucket,
                                    Key             = fixKey(key),
                                    InputStream     = ms,
                                    AutoCloseStream = false,
                                    ContentType     = "application/octet-stream",
                                };

                                putObj.Metadata.Add(_createdMetaTag, creationTime.ToString());
                                putObj.Metadata.Add(_expiresAtMetaTag, expirationTime.ToString());


                                var res = client.PutObjectAsync(putObj).Result;

                                //client.PutObjectAsync(this.Bucket, fixKey(key),
                                //ms, ms.Length,
                                //    "application/octet-stream",
                                //    meta
                                //    ).Wait();
                                //}
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    ESTraceLogger.Error($"AWS_S3CacheProvider: insert record {fixKey(key)} error {e.Message}", e);
                }
            }
            else
            {
                ESTraceLogger.Warning(new Devmasters.Log.LogMessage()
                                      .SetMessage("AWS_S3CacheProvider> null value")
                                      .SetLevel(Devmasters.Log.PriorityLevel.Warning)
                                      .SetCustomKeyValue("objectType", typeof(T).ToString())
                                      .SetCustomKeyValue("cache key", key)
                                      );
            }
        }