grails.project.dependency.resolution = {
    inherits "global"
    log "info"
    repositories {
        // your repositories
    }
    dependencies {
        // Workaround to resolve dependency issue with aws-java-sdk and http-builder (dependent on httpcore:4.0)
        build 'org.apache.httpcomponents:httpcore:4.3.2'
        build 'org.apache.httpcomponents:httpclient:4.3.2'
        runtime 'org.apache.httpcomponents:httpcore:4.3.2'
        runtime 'org.apache.httpcomponents:httpclient:4.3.2'
    }
    plugins {
        // here go your plugin dependencies
        runtime ':aws-sdk:1.9.40'
    }
}

grails.plugin.awssdk.accessKey = {ACCESS_KEY}
grails.plugin.awssdk.secretKey = {SECRET_KEY}

grails run-app -Daws.accessKeyId={ACCESS_KEY} -Daws.secretKey={SECRET_KEY}

grails.plugin.awssdk.region = 'eu-west-1'

grails {
    plugin {
        awssdk {
            // Amount of time to wait (in milliseconds) when initially establishing a connection before giving up and timing out.
            connectionTimeout = {CONNECTION_TIMEOUT}
            // Maximum number of allowed open HTTP connections.
            maxConnections = {MAX_CONNECTIONS}
            // Maximum number of retry attempts for failed retryable requests (ex: 5xx error responses from a service).
            maxErrorRetry = {MAX_ERROR_RETRY}
            // Protocol (HTTP or HTTPS) to use when connecting to Amazon Web Services.
            protocol = {PROTOCOL}
            // Size hints (in bytes) for the low level TCP send and receive buffers.
            socketBufferSizeHints = [{SOCKET_SEND_BUFFER _SIZE_HINT},{SOCKET_RECEIVE_BUFFER_SIZE_HINT}]
            // Amount of time to wait (in milliseconds) for data to be transfered over an established, open connection before the connection times out and is closed.
            socketTimeout = {SOCKET_TIMEOUT}
            // HTTP user agent header to send with all requests.
            userAgent = {USER_AGENT}
            // Proxy settings
            proxyDomain = {PROXY_DOMAIN}
            proxyHost = {PROXY_HOST}
            proxyPassword = {PROXY_PASSWORD}
            proxyPort = {PROXY_PORT}
            proxyUsername = {PROXY_USERNAME}
            proxyWorkstation = {PROXY_WORKSTATION}
        }
    }
}

grails {
    plugin {
        awssdk {
            accessKey = {ACCESS_KEY}    // Default access key
            secretKey = {SECRET_KEY}    // Default secret key
            region = 'eu-west-1'        // Default region
            sqs {
                accessKey = {SQS_ACCESS_KEY}    // Custom access key
                secretKey = {SQS_SECRET_KEY}    // Custom secret key
                region = {SQS_REGION}           // Custom region
                connectionTimeout = {SQS_CONNECTION_TIMEOUT}  // Custom timeout
            }
            ses {
                region = 'us-east-1'    // Since SES is currently only available in this region
            }
            // Other available services
            autoScaling {}
            cloudFormation {}
            cloudFront {}
            cloudSearch {}
            cloudTrail {}
            cloudWatch {}
            codeDeploy {}
            cognitoIdentity {}
            cognitoSync {}
            config {}
            dynamoDB {}
            ec2 {}
            elasticBeanstalk {}
            elasticLoadBalancing {}
            elasticMapReduce {}
            elasticTranscoder {}
            elastiCache {}
            glacier {}
            iam {}
            importExport {}
            kms {}
            kinesis {}
            opsWorks {}
            rds {}
            redshift {}
            route53 {}
            s3 {}
            s3Encryption {}
            sdb {}
            sns {}
            sqs {}
            storagegateway {}
            sts {}
            swf {}
        }
    }
}

def amazonWebService

def amazonWebService = ctx.amazonWebService

// Available service clients
amazonWebService.autoScaling
amazonWebService.cloudFormation
amazonWebService.cloudFront
amazonWebService.cloudSearch
amazonWebService.cloudSearchDomain
amazonWebService.cloudTrail
amazonWebService.cloudWatch
amazonWebService.codeDeploy
amazonWebService.cognitoIdentity
amazonWebService.cognitoSync
amazonWebService.config
amazonWebService.dynamoDB
amazonWebService.dynamoDBMapper
amazonWebService.ec2
amazonWebService.elasticBeanstalk
amazonWebService.elasticLoadBalancing
amazonWebService.elasticMapreduce
amazonWebService.elasticTranscoder
amazonWebService.elastiCache
amazonWebService.glacier
amazonWebService.iam
amazonWebService.importExport
amazonWebService.kinesis
amazonWebService.kms
amazonWebService.opsWorks
amazonWebService.rds
amazonWebService.redshift
amazonWebService.route53
amazonWebService.s3
amazonWebService.s3Encryption
amazonWebService.ses
amazonWebService.sdb
amazonWebService.sns
amazonWebService.sqs
amazonWebService.sqsBufferedAsync
amazonWebService.storageGateway
amazonWebService.swf
amazonWebService.transferManager

// Use SQS for region 'eu-west-1'
amazonWebService.getSqs('eu-west-1').sendMessage(new SendMessageRequest(queueUrl, messageBody))

// Get async client
amazonWebService.sqsAsync.sendMessageAsync(new SendMessageRequest(queueUrl, messageBody))
// Get async client for region 'eu-west-1'
amazonWebService.getSqsAsync('eu-west-1').sendMessageAsync(new SendMessageRequest(queueUrl, messageBody))

import com.amazonaws.services.ec2.model.*
// If your default region is eu-west-1
def reservation = amazonWebService.ec2.runInstances(new RunInstancesRequest('ami-fd231b89', 1, 1).withInstanceType('t1.micro'))
// Or if your default region is not eu-west-1 (this ami ID is only runnable eu-west-1)
def reservation = amazonWebService.getEc2('eu-west-1').runInstances(new RunInstancesRequest('ami-fd231b89', 1, 1).withInstanceType('t1.micro'))

List reservations = amazonWebService.ec2.describeInstances().reservations
reservations.each { Reservation reservation ->
    println "reservationId: ${reservation.reservationId}"
    reservation.instances.each() { Instance instance ->
        println "instanceId: ${instance.instanceId}, imageId: ${instance.imageId}, instanceType: ${instance.instanceType}"
    }
}

amazonWebService.ec2.stopInstances(new StopInstancesRequest([instanceId]))

amazonWebService.ec2.terminateInstances(new TerminateInstancesRequest([instanceId]))

import com.amazonaws.services.rds.model.*
DBInstance dbInstance = amazonWebService.rds.createDBInstance(new CreateDBInstanceRequest('mydbserver', 5, 'db.t1.micro', 'MySQL', 'admin', 'password'))

List dbInstances = amazonWebService.rds.describeDBInstances().DBInstances
dbInstances.each { DBInstance dbInstance ->
    println "DBInstanceIdentifier: ${dbInstance.DBInstanceIdentifier}, DBInstanceStatus: ${dbInstance.DBInstanceStatus}, engine: ${dbInstance.engine}, allocatedStorage: ${dbInstance.allocatedStorage}"
}

amazonWebService.rds.createDBSnapshot(new CreateDBSnapshotRequest('someSnapshot', 'mydbserver'))

amazonWebService.rds.deleteDBInstance(new DeleteDBInstanceRequest('mydbserver').withSkipFinalSnapshot(true))

import com.amazonaws.services.s3.model.*
// Bucket will be created in default config region
amazonWebService.s3.createBucket('some-grails-bucket')

List buckets = amazonWebService.s3.listBuckets()
buckets.each { Bucket bucket ->
    println "bucketName: ${bucket.name}, creationDate: ${bucket.creationDate}"
}

ObjectListing objectListing = amazonWebService.s3.listObjects('some-grails-bucket')
objectListing.objectSummaries.each { S3ObjectSummary summary ->
    println "key: ${summary.key}, lastModified: ${summary.lastModified}, size: ${summary.size}"
}

amazonWebService.s3.putObject(new PutObjectRequest('some-grails-bucket', 'somePath/someKey.jpg', new File('/Users/ben/Desktop/photo.jpg')).withCannedAcl(CannedAccessControlList.PublicRead))

amazonWebService.s3.getObject(new GetObjectRequest('some-grails-bucket', 'somePath/someKey.jpg'), new File('/Users/ben/Downloads/photo.jpg'))

amazonWebService.s3.deleteObject('some-grails-bucket', 'somePath/someKey.jpg')

import com.amazonaws.services.s3.model.CannedAccessControlList
import com.amazonaws.services.s3.transfer.*
PutObjectRequest putObjectRequest = new PutObjectRequest('some-grails-bucket', 'somePath/someKey.jpg', new File('/Users/ben/Desktop/photo.jpg')).withCannedAcl(CannedAccessControlList.PublicRead)
Upload upload = amazonWebService.transferManager.upload(putObjectRequest)
while (!upload.done) {
     println "Transfer: $upload.description"
     println "  - State: $upload.state"
     println "  - Progress: $upload.progress.bytesTransfered"
     // Do work while we wait for our upload to complete…
     Thread.sleep(500)
}

MultipleFileUpload upload = amazonWebService.transferManager.uploadDirectory('some-grails-bucket', 'some-virtual-directory', new File('/Users/ben/Desktop/SomeDirectory'), false)
while (!upload.done) {
     println "Transfer: $upload.description"
     println "  - State: $upload.state"
     println "  - Progress: $upload.progress.bytesTransfered"
     // Do work while we wait for our upload to complete…
     Thread.sleep(500)
}

Download download = amazonWebService.transferManager.download(new GetObjectRequest('some-grails-bucket', 'somePath/someKey.jpg'),  new File('/Users/ben/Downloads/photo.jpg'))
while (!download.done) {
     println "Transfer: $download.description"
     println "  - State: $download.state"
     println "  - Progress: $download.progress.bytesTransfered"
     // Do work while we wait for our upload to complete…
     Thread.sleep(500)
}

MultipleFileDownload download = amazonWebService.transferManager.downloadDirectory('some-grails-bucket', 'some-virtual-directory',  new File('/Users/ben/Downloads'))
while (!download.done) {
     println "Transfer: $download.description"
     println "  - State: $download.state"
     println "  - Progress: $download.progress.bytesTransfered"
     // Do work while we wait for our upload to complete…
     Thread.sleep(500)
}

import com.amazonaws.services.simpleemail.model.*
amazonWebService.ses.verifyEmailIdentity(new VerifyEmailIdentityRequest().withEmailAddress('notification@mydomain.com'))

List emailAddresses = amazonWebService.ses.listVerifiedEmailAddresses().verifiedEmailAddresses
emailAddresses.each {
    println it
}

String source = 'notification@mydomain.com'
Destination destination = new Destination(['myemail@gmail.com'])
Content subject = new Content('Some subject...')
Body body = new Body().withHtml(new Content('''Hi,<br />
<br />
Some <b>HTML</b> body…
'''))
Message message = new Message(subject, body)
amazonWebService.ses.sendEmail(new SendEmailRequest(source, destination, message))

GetSendStatisticsResult statistics = amazonWebService.ses.getSendStatistics()
statistics.sendDataPoints.each { SendDataPoint sendDataPoint ->
    println "bounces=${sendDataPoint.bounces}, complaints=${sendDataPoint.complaints}, deliveryAttempts=${sendDataPoint.deliveryAttempts}, rejects=${sendDataPoint.rejects}"
}

GetSendQuotaResult quota = amazonWebService.ses.getSendQuota()
println "max24HourSend: ${quota.max24HourSend}, sentLast24Hours: ${quota.sentLast24Hours}, sentLast24Hours: ${quota.sentLast24Hours}"

import com.amazonaws.services.sqs.model.*
String queueUrl = amazonWebService.sqs.createQueue(new CreateQueueRequest('someQueue')).queueUrl

amazonWebService.sqs.sendMessage(new SendMessageRequest(queueUrl, 'Some message...'))

List messages = amazonWebService.sqs.receiveMessage(new ReceiveMessageRequest(queueUrl)).messages
messages.each { Message message ->
    println "id: ${message.messageId}, body: ${message.body}"
    amazonWebService.sqs.deleteMessage(new DeleteMessageRequest(queueUrl, message.receiptHandle))
}

amazonWebService.sqs.deleteQueue(new DeleteQueueRequest('someQueue'))