enscalator 0.4.0.pre.alpha.pre.16

data/lib/enscalator/plugins/nat_gateway.rb

@@ -0,0 +1,71 @@
+module Enscalator
+  module Plugins
+    # VPC NAT Gateway plugin
+    module NATGateway
+      # Allocate new elastic IP in given VPC template
+      #
+      # @param [String] name eip resource name
+      # @param [Array<String>] depends_on list of resource names this resource depends on
+      # @return [Hash] result of Fn::GetAtt function
+      def allocate_new_eip(name, depends_on: [])
+        fail('Dependency on the VPC-gateway attachment must be provided') if depends_on.empty?
+        eip_resource_name = name
+        resource eip_resource_name,
+                 DependsOn: depends_on,
+                 Type: 'AWS::EC2::EIP',
+                 Properties: {
+                   Domain: 'vpc'
+                 }
+
+        output eip_resource_name,
+               Description: 'Elastic IP address for NAT Gateway',
+               Value: ref(eip_resource_name)
+
+        get_att(eip_resource_name, 'AllocationId')
+      end
+
+      # Create new route rule
+      #
+      # @param [String] name route rule name
+      # @param [Array<String>] depends_on list of resource names this resource depends on
+      def add_route_rule(name, route_table_name, nat_gateway_name, dest_cidr_block, depends_on: [])
+        options = {
+          Type: 'AWS::EC2::Route'
+        }
+        options[:DependsOn] = depends_on unless depends_on.blank?
+        resource name,
+                 options.merge(
+                   Properties: {
+                     RouteTableId: ref(route_table_name),
+                     NatGatewayId: ref(nat_gateway_name),
+                     DestinationCidrBlock: dest_cidr_block
+                   })
+      end
+
+      # Create new NAT gateway
+      def nat_gateway_init(name, subnet_name, route_table_name, dest_cidr_block: '0.0.0.0/0', depends_on: [])
+        nat_gateway_eip_name = "#{name}EIP"
+        nat_gateway_eip = allocate_new_eip(nat_gateway_eip_name, depends_on: depends_on)
+        nat_gateway_name = name
+        nat_gateway_options = {
+          Type: 'AWS::EC2::NatGateway'
+        }
+        nat_gateway_options[:DependsOn] = depends_on unless depends_on.blank?
+        resource nat_gateway_name,
+                 nat_gateway_options.merge(
+                   Properties: {
+                     AllocationId: nat_gateway_eip,
+                     SubnetId: ref(subnet_name)
+                   })
+        nat_route_rule_name = "#{name}Route"
+        add_route_rule(nat_route_rule_name, route_table_name, nat_gateway_name, dest_cidr_block, depends_on: depends_on)
+
+        output nat_gateway_name,
+               Description: 'NAT Gateway',
+               Value: ref(nat_gateway_name)
+
+        nat_gateway_name
+      end
+    end
+  end
+end

data/lib/enscalator/plugins/rds.rb

@@ -0,0 +1,141 @@
+module Enscalator
+  module Plugins
+    # Amazon RDS instance
+    module RDS
+      # Create new Amazon RDS instance
+      #
+      # @param [String] db_name database name
+      # @param [Boolean] use_snapshot use snapshot or not
+      # @param [Integer] allocated_storage size of instance primary storage
+      # @param [String] storage_type instance storage type
+      # @param [String] multizone deploy as multizone or use only single availability zone
+      # @param [String] parameter_group RDS instance parameter group
+      # @param [String] instance_type instance type
+      # @param [Hash] properties additional properties
+      def rds_init(db_name,
+                   use_snapshot: false,
+                   allocated_storage: 5,
+                   storage_type: 'gp2',
+                   multizone: 'false',
+                   engine: 'MySQL',
+                   engine_version: '5.6',
+                   parameter_group: 'default.mysql5.6',
+                   instance_type: 'db.t2.small',
+                   properties: {})
+
+        parameter_name "RDS#{db_name}"
+
+        parameter_rds_instance_type "RDS#{db_name}", type: instance_type
+
+        parameter_allocated_storage "RDS#{db_name}",
+                                    default: allocated_storage,
+                                    min: 5,
+                                    max: 1024
+
+        parameter "RDS#{db_name}Engine",
+                  Default: engine,
+                  Description: 'DB engine type of the DB instance',
+                  Type: 'String'
+
+        parameter "RDS#{db_name}EngineVersion",
+                  Default: engine_version,
+                  Description: 'DB engine version of the DB instance',
+                  Type: 'String'
+
+        parameter "RDS#{db_name}StorageType",
+                  Default: storage_type,
+                  Description: 'Storage type to be associated with the DB instance',
+                  Type: 'String',
+                  AllowedValues: %w( gp2 standard io1 )
+
+        parameter "RDS#{db_name}Multizone",
+                  Default: multizone,
+                  Description: 'Multizone deployment',
+                  Type: 'String'
+
+        parameter "RDS#{db_name}ParameterGroup",
+                  Default: parameter_group,
+                  Description: 'Custom parameter group for an RDS database family',
+                  Type: 'String'
+
+        parameter_username "RDS#{db_name}"
+
+        parameter_password "RDS#{db_name}"
+
+        resource "RDS#{db_name}SubnetGroup",
+                 Type: 'AWS::RDS::DBSubnetGroup',
+                 Properties: {
+                   DBSubnetGroupDescription: 'Subnet group within VPC',
+                   SubnetIds: ref_resource_subnets,
+                   Tags: [
+                     {
+                       Key: 'Name',
+                       Value: "RDS#{db_name}SubnetGroup"
+                     }
+                   ]
+                 }
+
+        # DBName and DBSnapshotIdentifier are mutually exclusive, thus
+        # when snapshot_id is given DBName won't be included to resource parameters
+        props = properties.deep_dup
+        if use_snapshot
+          parameter "RDS#{db_name}SnapshotId",
+                    Description: 'Identifier for the DB snapshot to restore from',
+                    Type: 'String',
+                    MinLength: '1',
+                    MaxLength: '64'
+          props[:DBSnapshotIdentifier] = ref("RDS#{db_name}SnapshotId")
+        else
+          props[:DBName] = ref("RDS#{db_name}Name")
+        end
+
+        rds_instance_tags = [
+          {
+            Key: 'Name',
+            Value: "RDS#{db_name}Instance"
+          }
+        ]
+
+        # Set instance tags
+        if props.key?(:Tags) && !props[:Tags].empty?
+          props[:Tags].concat(rds_instance_tags)
+        else
+          props[:Tags] = rds_instance_tags
+        end
+
+        rds_props = {
+          PubliclyAccessible: 'false',
+          MultiAZ: ref("RDS#{db_name}Multizone"),
+          Engine: ref("RDS#{db_name}Engine"),
+          EngineVersion: ref("RDS#{db_name}EngineVersion"),
+          MasterUsername: ref("RDS#{db_name}Username"),
+          MasterUserPassword: ref("RDS#{db_name}Password"),
+          DBInstanceClass: ref("RDS#{db_name}InstanceType"),
+          VPCSecurityGroups: [ref_resource_security_group, ref_private_security_group],
+          DBSubnetGroupName: ref("RDS#{db_name}SubnetGroup"),
+          DBParameterGroupName: ref("RDS#{db_name}ParameterGroup"),
+          AllocatedStorage: ref("RDS#{db_name}AllocatedStorage"),
+          StorageType: ref("RDS#{db_name}StorageType")
+        }
+
+        rds_instance_resource_name = "RDS#{db_name}Instance"
+        resource rds_instance_resource_name,
+                 Type: 'AWS::RDS::DBInstance',
+                 Properties: rds_props.merge(props)
+
+        output "RDS#{db_name}EndpointAddress",
+               Description: "#{db_name} Endpoint Address",
+               Value: get_att("RDS#{db_name}Instance", 'Endpoint.Address')
+
+        rds_instance_resource_name
+      end
+
+      # Ensure that plugin using this template is a subclass of EnAppTemplateDSL
+      def self.included(klass)
+        if klass.superclass != Enscalator::EnAppTemplateDSL
+          fail("Plugin #{name.to_s.demodulize} requires template to be subclass of #{EnAppTemplateDSL}")
+        end
+      end
+    end # RDS
+  end # Plugins
+end # Enscalator

data/lib/enscalator/plugins/redis.rb

@@ -0,0 +1,38 @@
+module Enscalator
+  module Plugins
+    # Redis on EC2 instance
+    module Redis
+      include Enscalator::Plugins::Ubuntu
+
+      # Create new Redis instance
+      #
+      # @param [String] instance_name instance name
+      # @param [String] key_name instance key
+      # @param [String] instance_type instance type
+      def redis_init(instance_name,
+                     key_name:,
+                     instance_type: 't2.medium')
+
+        parameter "Ubuntu#{instance_name}KeyName",
+                  Default: key_name,
+                  Description: 'Keypair name',
+                  Type: 'String'
+
+        ubuntu_init instance_name, instance_type: instance_type, properties: { 'UserData' => redis_user_data }
+      end
+
+      # Install and run Redis on EC2 instance
+      # @return [String] user-data
+      def redis_user_data
+        Base64.encode64(%(
+          #!/usr/bin/env bash
+          apt-get update
+          apt-get upgrade -y
+          apt-get install -y redis-server
+          sed -i 's/bind 127.0.0.1/bind 0.0.0.0/' /etc/redis/redis.conf
+          service redis-server restart
+        ).gsub(/^\s+/, ''))
+      end
+    end # Redis
+  end # Plugins
+end # Enscalator

data/lib/enscalator/plugins/rethink_db.rb

@@ -0,0 +1,21 @@
+module Enscalator
+  module Plugins
+    # RethinkDB appliance
+    module RethinkDB
+      # Mapping for Rethinkdb x64 images
+      def self.mapping
+        {
+          'eu-central-1': { paravirtual: 'ami-1249740f' },
+          'eu-west-1': { paravirtual: 'ami-7a40f00d' },
+          'ap-northeast-1': { paravirtual: 'ami-90c3c491' },
+          'us-east-1': { paravirtual: 'ami-6ea9fb06' },
+          'us-west-1': { paravirtual: 'ami-7f6d7d3a' },
+          'us-west-2': { paravirtual: 'ami-cf0d2cff' },
+          'ap-southeast-1': { paravirtual: 'ami-aa5b6cf8' },
+          'ap-southeast-2': { paravirtual: 'ami-b9325b83' },
+          'sa-east-1': { paravirtual: 'ami-b38b3aae' }
+        }.with_indifferent_access
+      end
+    end # RethinkDB
+  end # Plugins
+end # Enscalator

data/lib/enscalator/plugins/route53.rb

@@ -0,0 +1,143 @@
+module Enscalator
+  module Plugins
+    # Create Route53 resources
+    module Route53
+      # Valid types for Route53 healthcheck
+      HEALTH_CHECK_TYPE = %w(HTTP HTTPS HTTP_STR_MATCH HTTPS_STR_MATCH TCP)
+
+      # Valid types for dns records
+      RECORD_TYPE = %w(A AAAA CNAME MX NS PTR SOA SPF SRV TXT)
+
+      # Create Route53 healthcheck for given fqdn/ip address
+      #
+      # @param [String] app_name application name
+      # @param [String] stack_name stack name
+      # @param [String] fqdn fully qualified domain name (FQDN)
+      # @param [String] ip_address ip address
+      # @param [Integer] port number
+      # @param [String] type healthcheck type
+      # @param [String] resource_path uri path healthcheck backend would query
+      # @param [Integer] request_interval query intervals for healthcheck backend
+      # @param [Integer] failure_threshold number of accumulated failures to consider endpoint not healthy
+      # @param [Array] tags additional tags
+      def create_healthcheck(app_name,
+                             stack_name,
+                             fqdn: nil,
+                             ip_address: nil,
+                             port: 80,
+                             type: 'HTTP',
+                             resource_path: '/',
+                             request_interval: 30,
+                             failure_threshold: 3,
+                             tags: [])
+        unless HEALTH_CHECK_TYPE.include?(type)
+          fail("Route53 healthcheck type can only be one of the following: #{HEALTH_CHECK_TYPE.join(',')}")
+        end
+        fail('Route53 healthcheck requires either fqdn or ip address') unless fqdn || ip_address
+
+        properties = {
+          HealthCheckConfig: {
+            IPAddress: ip_address,
+            FullyQualifiedDomainName: fqdn,
+            Port: port,
+            Type: type,
+            ResourcePath: resource_path,
+            RequestInterval: request_interval,
+            FailureThreshold: failure_threshold
+          }
+        }
+
+        properties[:HealthCheckTags] = [
+          {
+            Key: 'Application',
+            Value: app_name
+          },
+          {
+            Key: 'Stack',
+            Value: stack_name
+          }
+        ]
+
+        properties[:HealthCheckTags].concat(tags) unless tags.blank?
+
+        resource "#{app_name}Healthcheck",
+                 Type: 'AWS::Route53::HealthCheck',
+                 Properties: properties
+      end
+
+      # [RESERVED] Create new hosted zone
+      def create_hosted_zone
+        fail('method "create_hosted_zone" is not implemented yet')
+      end
+
+      # TODO: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-recordset.html
+
+      # Create new single record set for given hosted zone
+      #
+      # @param [String] app_name application name
+      # @param [String] stack_name stack name
+      # @param [String] zone_name hosted zone name
+      # @param [String] record_name dns record name
+      # @param [Integer] ttl time to live
+      # @param [String] type dns record type
+      # @param [Hash] healthcheck reference to the healthcheck resource
+      # @param [Hash] alias_target alias target
+      # @param [Array] resource_records resources associated with record_name
+      def create_single_dns_record(app_name,
+                                   stack_name,
+                                   zone_name,
+                                   record_name,
+                                   ttl: 300,
+                                   type: 'A',
+                                   healthcheck: nil,
+                                   zone_id: nil,
+                                   alias_target: {},
+                                   resource_records: [])
+        if type && !RECORD_TYPE.include?(type)
+          fail("Route53 record type can only be one of the following: #{RECORD_TYPE.join(',')}")
+        end
+        if healthcheck && (!healthcheck.is_a?(Hash) || !healthcheck.include?(:Ref))
+          fail('healthcheck must be a valid cloudformation Ref function')
+        end
+        if alias_target && (!alias_target.is_a?(Hash))
+          fail('AliasTarget must be a Hash')
+        end
+
+        name = app_name || stack_name.titleize.remove(/\s/)
+        properties = {
+          Name: record_name,
+          Comment: "#{type} record for #{[app_name, 'in '].join(' ') if app_name}#{stack_name} stack",
+          Type: type
+        }
+
+        # HostedZoneId and HostedZoneName options are mutually exclusive
+        if zone_id && !zone_id.nil?
+          properties[:HostedZoneId] = zone_id
+        else
+          properties[:HostedZoneName] = zone_name
+        end
+
+        if !alias_target.blank?
+          fail('AliasTarget can be created only for A or AAAA type records') unless %w(A AAAA).include?(type)
+          unless alias_target.key?(:HostedZoneId) && alias_target.key?(:DNSName)
+            fail('AliasTarget must have HostedZoneId and DNSName properties')
+          end
+          properties[:AliasTarget] = alias_target
+        else
+          properties[:TTL] = ttl
+          properties[:HealthCheckId] = healthcheck if healthcheck
+          properties[:ResourceRecords] = resource_records.empty? ? ref("#{app_name}PublicIpAddress") : resource_records
+        end
+
+        resource "#{name}Hostname",
+                 Type: 'AWS::Route53::RecordSet',
+                 Properties: properties
+      end
+
+      # [RESERVED] Create multiple record sets for given hosted zone
+      def create_multiple_dns_records
+        fail('method "create_multiple_dns_records" is not implemented')
+      end
+    end # module Route53
+  end # module Plugins
+end # module Enscalator

data/lib/enscalator/plugins/ubuntu.rb

@@ -0,0 +1,85 @@
+module Enscalator
+  module Plugins
+    # Ubuntu appliance
+    module Ubuntu
+      class << self
+        # Supported storage types in AWS
+        STORAGE = [:ebs, :'ebs-io1', :'ebs-ssd', :'instance-store']
+
+        # Supported Ubuntu image architectures
+        ARCH = [:amd64, :i386]
+
+        # Supported Ubuntu releases
+        RELEASE = {
+          vivid: '15.04',
+          utopic: '14.10',
+          trusty: '14.04',
+          saucy: '13.10',
+          raring: '13.04',
+          quantal: '12.10',
+          precise: '12.04'
+        }
+
+        # Structure to hold parsed record
+        Struct.new('Ubuntu', :name, :edition, :state, :timestamp, :root_storage, :arch, :region, :ami, :virtualization)
+
+        # Get mapping for Ubuntu images
+        #
+        # @param [Symbol, String] release a codename or version number
+        # @param [Symbol] storage storage kind
+        # @param [Symbol] arch architecture
+        # @raise [ArgumentError] if release is nil, empty or not one of supported values
+        # @raise [ArgumentError] if storage is nil, empty or not one of supported values
+        # @raise [ArgumentError] if arch is nil, empty or not one of supported values
+        # @return [Hash] mapping for Ubuntu amis
+        def get_mapping(release: :trusty, storage: :ebs, arch: :amd64)
+          fail ArgumentError, 'release can be either codename or version' unless RELEASE.to_a.flatten.include? release
+          fail ArgumentError, "storage can only be one of #{STORAGE}" unless STORAGE.include? storage
+          fail ArgumentError, "arch can only be one of #{ARCH}" unless ARCH.include? arch
+          begin
+            version = RELEASE.keys.include?(release) ? release : RELEASE.key(release)
+            body = open("https://cloud-images.ubuntu.com/query/#{version}/server/released.current.txt") { |f| f.read }
+            body.split("\n").map { |m| m.squeeze("\t").split("\t").reject { |r| r.include? 'aki' } }
+              .map { |l| Struct::Ubuntu.new(*l) }
+              .select { |r| r.root_storage == storage.to_s && r.arch == arch.to_s }
+              .group_by(&:region)
+              .map { |k, v| [k, v.map { |i| [i.virtualization, i.ami] }.to_h] }
+              .to_h
+              .with_indifferent_access
+          end
+        end
+      end # class << self
+
+      # Create new Ubuntu instance
+      #
+      # @param [String] instance_name instance name
+      # @param [String] storage storage kind (ebs or ephemeral)
+      # @param [String] arch architecture (amd64 or i386)
+      # @param [String] instance_type instance type
+      def ubuntu_init(instance_name,
+                      storage: :ebs,
+                      arch: :amd64,
+                      instance_type: 't2.medium', properties: {})
+
+        mapping 'AWSUbuntuAMI', Ubuntu.get_mapping(storage: storage, arch: arch)
+
+        parameter_allocated_storage "Ubuntu#{instance_name}",
+                                    default: 5,
+                                    min: 5,
+                                    max: 1024
+
+        parameter_ec2_instance_type "Ubuntu#{instance_name}", type: instance_type
+
+        instance_vpc "Ubuntu#{instance_name}",
+                     find_in_map('AWSUbuntuAMI', ref('AWS::Region'), 'hvm'),
+                     ref_application_subnets.first,
+                     [ref_private_security_group, ref_application_security_group],
+                     depends_on: [],
+                     properties: {
+                       KeyName: ref("Ubuntu#{instance_name}KeyName"),
+                       InstanceType: ref("Ubuntu#{instance_name}InstanceType")
+                     }.merge(properties)
+      end
+    end # Ubuntu
+  end # Plugins
+end # Enscalator