formatron 0.1.0

data/lib/formatron/cli/generators/credentials.rb

@@ -0,0 +1,100 @@
+require 'formatron/generators/credentials'
+require 'formatron/aws'
+
+class Formatron
+  class CLI
+    module Generators
+      # CLI command for credentials generator
+      module Credentials
+        def self.dot_credentials
+          File.join '.formatron', 'credentials.json'
+        end
+
+        def self.global_credentials
+          File.join Dir.home, dot_credentials
+        end
+
+        def self.local_credentials(directory)
+          File.join directory, dot_credentials
+        end
+
+        def self.default_credentials(directory)
+          local = local_credentials directory
+          if File.file?(local)
+            local
+          else
+            global_credentials
+          end
+        end
+
+        def self.default_generated_credentials(directory)
+          if File.file?(File.join(directory, 'Formatronfile'))
+            local_credentials(directory)
+          else
+            global_credentials
+          end
+        end
+
+        def credentials_options(c)
+          c.option '-r', '--region STRING', 'The AWS region'
+          c.option '-a', '--access-key-id STRING', 'The AWS access key ID'
+          c.option(
+            '-s',
+            '--secret-access-key STRING',
+            'The AWS secret access key'
+          )
+        end
+
+        def credentials_directory(options)
+          options.directory || Dir.pwd
+        end
+
+        def credentials_credentials(options)
+          options.credentials ||
+            ask('Credentials file? ') do |q|
+              q.default =
+                Credentials.default_generated_credentials(
+                  credentials_directory(options)
+                )
+            end
+        end
+
+        def credentials_region(options)
+          options.region || choose(
+            'Region:',
+            *Formatron::AWS::REGIONS.keys
+          )
+        end
+
+        def credentials_access_key_id(options)
+          options.access_key_id || ask('Access Key ID? ')
+        end
+
+        def credentials_secret_access_key(options)
+          options.secret_access_key || password('Secret Access Key? ')
+        end
+
+        def credentials_action(c)
+          c.action do |_args, options|
+            Formatron::Generators::Credentials.generate(
+              credentials_credentials(options),
+              credentials_region(options),
+              credentials_access_key_id(options),
+              credentials_secret_access_key(options)
+            )
+          end
+        end
+
+        def credentials_formatron_command
+          command :'generate credentials' do |c|
+            c.syntax = 'formatron generate credentials [options]'
+            c.summary = 'Generate a credentials JSON file'
+            c.description = 'Generate a credentials JSON file'
+            credentials_options c
+            credentials_action c
+          end
+        end
+      end
+    end
+  end
+end

data/lib/formatron/cli/generators/instance.rb

@@ -0,0 +1,118 @@
+require 'formatron/generators/instance'
+
+class Formatron
+  class CLI
+    module Generators
+      # CLI command for instance generator
+      module Instance
+        # rubocop:disable Metrics/MethodLength
+        def instance_options(c)
+          c.option '-n', '--name STRING', 'The name for the configuration'
+          c.option '-i', '--instance-name STRING', 'The name for the instance'
+          c.option(
+            '-s',
+            '--s3-bucket STRING',
+            'The S3 bucket to store encrypted configuration'
+          )
+          c.option(
+            '-b',
+            '--bootstrap-configuration STRING',
+            'The name of the bootstrap configuration to depend on'
+          )
+          c.option(
+            '-p',
+            '--vpc STRING',
+            'The name of the VPC to add the instance to'
+          )
+          c.option(
+            '-u',
+            '--subnet STRING',
+            'The name of the subnet to add the instance to'
+          )
+          c.option(
+            '-x',
+            '--targets LIST',
+            Array,
+            'The targets (eg. production test)'
+          )
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def instance_directory(options)
+          options.directory || ask('Directory? ') do |q|
+            q.default = Dir.pwd
+          end
+        end
+
+        def instance_name(options, directory)
+          options.name || ask('Name? ') do |q|
+            q.default = File.basename directory
+          end
+        end
+
+        def instance_instance_name(options, name)
+          options.instance_name || ask('Instance Name? ') do |q|
+            q.default = name
+          end
+        end
+
+        def instance_s3_bucket(options)
+          options.s3_bucket || ask('S3 Bucket? ')
+        end
+
+        def instance_bootstrap_configuration(options)
+          options.bootstrap_configuration ||
+            ask('Bootstrap configuration? ')
+        end
+
+        def instance_vpc(options)
+          options.vpc || ask('VPC? ') do |q|
+            q.default = 'vpc'
+          end
+        end
+
+        def instance_subnet(options)
+          options.subnet || ask('Subnet? ') do |q|
+            q.default = 'private'
+          end
+        end
+
+        def instance_targets(options)
+          options.targets || ask('Targets? ', Array) do |q|
+            q.default = 'production test'
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def instance_action(c)
+          c.action do |_args, options|
+            directory = instance_directory options
+            name = instance_name options, directory
+            Formatron::Generators::Instance.generate(
+              directory,
+              name: name,
+              instance_name: instance_instance_name(options, name),
+              s3_bucket: instance_s3_bucket(options),
+              bootstrap_configuration:
+                instance_bootstrap_configuration(options),
+              vpc: instance_vpc(options),
+              subnet: instance_subnet(options),
+              targets: instance_targets(options)
+            )
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def instance_formatron_command
+          command :'generate instance' do |c|
+            c.syntax = 'formatron generate instance [options]'
+            c.summary = 'Generate an instance configuration'
+            c.description = 'Generate an instance configuration'
+            instance_options c
+            instance_action c
+          end
+        end
+      end
+    end
+  end
+end

data/lib/formatron/cli/provision.rb

@@ -0,0 +1,59 @@
+require 'formatron'
+require 'formatron/config'
+
+class Formatron
+  class CLI
+    # CLI command for provision
+    module Provision
+      def provision_directory(options)
+        options.directory || Dir.pwd
+      end
+
+      def provision_credentials(options)
+        options.credentials ||
+          Generators::Credentials.default_credentials(
+            deploy_directory(options)
+          )
+      end
+
+      def provision_target(target, directory)
+        target || choose(
+          'Target?',
+          *Config.targets(directory: directory)
+        )
+      end
+
+      def provision_ok(formatron, target)
+        !formatron.protected? || agree(
+          "Are you sure you wish to provision protected target: #{target}?"
+        ) do |q|
+          q.default = 'no'
+        end
+      end
+
+      def provision_action(c)
+        c.action do |args, options|
+          directory = provision_directory options
+          target = provision_target args[0], directory
+          formatron = Formatron.new(
+            credentials: provision_credentials(options),
+            directory: directory,
+            target: target
+          )
+          formatron.provision if provision_ok formatron, target
+        end
+      end
+
+      def provision_formatron_command
+        command :provision do |c|
+          c.syntax = 'formatron provision [options] [TARGET]'
+          c.summary = 'Provision the instances in a Formatron ' \
+                      'stack using Opscode Chef'
+          c.description = 'Provision the instances in a Formatron ' \
+                          'stack using Opscode Chef'
+          provision_action c
+        end
+      end
+    end
+  end
+end

data/lib/formatron/cloud_formation.rb

@@ -0,0 +1,54 @@
+require_relative 's3/cloud_formation_template'
+require 'formatron/logger'
+
+class Formatron
+  # manage the CloudFormation stack
+  module CloudFormation
+    # rubocop:disable Metrics/MethodLength
+    def self.deploy(aws:, bucket:, name:, target:, parameters:)
+      stack_name = _stack_name name, target
+      Formatron::LOG.info do
+        "Deploy CloudFormation stack: #{stack_name}"
+      end
+      aws.deploy_stack(
+        stack_name: stack_name,
+        template_url: S3::CloudFormationTemplate.url(
+          region: aws.region,
+          bucket: bucket,
+          name: name,
+          target: target
+        ),
+        parameters: parameters
+      )
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.destroy(aws:, name:, target:)
+      stack_name = _stack_name name, target
+      Formatron::LOG.info do
+        "Destroy CloudFormation stack: #{stack_name}"
+      end
+      aws.delete_stack stack_name: stack_name
+    end
+
+    def self.outputs(aws:, name:, target:)
+      stack_name = _stack_name name, target
+      Formatron::LOG.info do
+        "Query CloudFormation stack outputs: #{stack_name}"
+      end
+      aws.stack_outputs stack_name: stack_name
+    end
+
+    def self.stack_ready!(aws:, name:, target:)
+      aws.stack_ready! stack_name: _stack_name(name, target)
+    end
+
+    def self._stack_name(name, target)
+      "#{name}-#{target}"
+    end
+
+    private_class_method(
+      :_stack_name
+    )
+  end
+end

data/lib/formatron/cloud_formation/resources/cloud_formation.rb

@@ -0,0 +1,27 @@
+require_relative '../template'
+
+class Formatron
+  module CloudFormation
+    module Resources
+      # Generates CloudFormation template CloudFormation resources
+      module CloudFormation
+        def self.wait_condition_handle
+          {
+            Type: 'AWS::CloudFormation::WaitConditionHandle'
+          }
+        end
+
+        def self.wait_condition(instance:, wait_condition_handle:)
+          {
+            Type: 'AWS::CloudFormation::WaitCondition',
+            DependsOn: instance,
+            Properties: {
+              Handle: Template.ref(wait_condition_handle),
+              Timeout: '1800'
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/formatron/cloud_formation/resources/ec2.rb

@@ -0,0 +1,336 @@
+require_relative '../template'
+
+class Formatron
+  module CloudFormation
+    module Resources
+      # Generates CloudFormation template EC2 resources
+      # rubocop:disable Metrics/ModuleLength
+      module EC2
+        def self.vpc(cidr:)
+          {
+            Type: 'AWS::EC2::VPC',
+            Properties: {
+              CidrBlock: cidr,
+              EnableDnsSupport: true,
+              EnableDnsHostnames: true,
+              InstanceTenancy: 'default'
+            }
+          }
+        end
+
+        def self.internet_gateway
+          {
+            Type: 'AWS::EC2::InternetGateway'
+          }
+        end
+
+        def self.vpc_gateway_attachment(vpc:, gateway:)
+          {
+            Type: 'AWS::EC2::VPCGatewayAttachment',
+            Properties: {
+              InternetGatewayId: Template.ref(gateway),
+              VpcId: Template.ref(vpc)
+            }
+          }
+        end
+
+        def self.route_table(vpc:)
+          {
+            Type: 'AWS::EC2::RouteTable',
+            Properties: {
+              VpcId: Template.ref(vpc)
+            }
+          }
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def self.route(
+          route_table:,
+          instance: nil,
+          internet_gateway: nil,
+          vpc_gateway_attachment: nil
+        )
+          properties = {
+            RouteTableId: Template.ref(route_table),
+            DestinationCidrBlock: '0.0.0.0/0'
+          }
+          properties[:GatewayId] =
+            Template.ref internet_gateway unless internet_gateway.nil?
+          properties[:InstanceId] =
+            Template.ref instance unless instance.nil?
+          route = {
+            Type: 'AWS::EC2::Route',
+            Properties: properties
+          }
+          route[:DependsOn] =
+            vpc_gateway_attachment unless vpc_gateway_attachment.nil?
+          route
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # rubocop:disable Metrics/MethodLength
+        def self.subnet(
+          vpc:,
+          cidr:,
+          availability_zone:,
+          map_public_ip_on_launch:
+        )
+          {
+            Type: 'AWS::EC2::Subnet',
+            Properties: {
+              VpcId: Template.ref(vpc),
+              CidrBlock: cidr,
+              MapPublicIpOnLaunch: map_public_ip_on_launch,
+              AvailabilityZone: Template.join(
+                Template.ref('AWS::Region'),
+                availability_zone
+              )
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def self.subnet_route_table_association(route_table:, subnet:)
+          {
+            Type: 'AWS::EC2::SubnetRouteTableAssociation',
+            Properties: {
+              RouteTableId: Template.ref(route_table),
+              SubnetId: Template.ref(subnet)
+            }
+          }
+        end
+
+        def self.network_acl(vpc:)
+          {
+            Type: 'AWS::EC2::NetworkAcl',
+            Properties: {
+              VpcId: Template.ref(vpc)
+            }
+          }
+        end
+
+        def self.subnet_network_acl_association(subnet:, network_acl:)
+          {
+            Type: 'AWS::EC2::SubnetNetworkAclAssociation',
+            Properties: {
+              SubnetId: Template.ref(subnet),
+              NetworkAclId: Template.ref(network_acl)
+            }
+          }
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/ParameterLists
+        def self.network_acl_entry(
+          network_acl:,
+          cidr:,
+          egress:,
+          protocol:,
+          action:,
+          icmp_code: nil,
+          icmp_type: nil,
+          start_port: nil,
+          end_port: nil,
+          number:
+        )
+          resource = {
+            Type: 'AWS::EC2::NetworkAclEntry',
+            Properties: {
+              NetworkAclId: Template.ref(network_acl),
+              CidrBlock: cidr,
+              Egress: egress,
+              Protocol: protocol,
+              RuleAction: action,
+              RuleNumber: number
+            }
+          }
+          resource[:Properties][:Icmp] = {
+            Code: icmp_code,
+            Type: icmp_type
+          } unless icmp_code.nil?
+          resource[:Properties][:PortRange] = {
+            From: start_port,
+            To: end_port
+          } unless start_port.nil?
+          resource
+        end
+        # rubocop:enable Metrics/ParameterLists
+        # rubocop:enable Metrics/MethodLength
+
+        # rubocop:disable Metrics/MethodLength
+        def self.security_group(
+          group_description:,
+          vpc:,
+          egress:,
+          ingress:
+        )
+          {
+            Type: 'AWS::EC2::SecurityGroup',
+            Properties: {
+              GroupDescription: group_description,
+              VpcId: Template.ref(vpc),
+              SecurityGroupEgress: egress.collect do |rule|
+                {
+                  CidrIp: rule[:cidr],
+                  IpProtocol: rule[:protocol],
+                  FromPort: rule[:from_port],
+                  ToPort: rule[:to_port]
+                }
+              end,
+              SecurityGroupIngress: ingress.collect do |rule|
+                {
+                  CidrIp: rule[:cidr],
+                  IpProtocol: rule[:protocol],
+                  FromPort: rule[:from_port],
+                  ToPort: rule[:to_port]
+                }
+              end
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # rubocop:disable Metrics/MethodLength
+        def self.security_group_egress(
+          security_group:,
+          cidr:,
+          protocol:,
+          from_port:,
+          to_port:
+        )
+          {
+            Type: 'AWS::EC2::SecurityGroupEgress',
+            Properties: {
+              GroupId: Template.ref(security_group),
+              CidrIp: cidr,
+              IpProtocol: protocol,
+              FromPort: from_port,
+              ToPort: to_port
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # rubocop:disable Metrics/MethodLength
+        def self.security_group_ingress(
+          security_group:,
+          cidr:,
+          protocol:,
+          from_port:,
+          to_port:
+        )
+          {
+            Type: 'AWS::EC2::SecurityGroupIngress',
+            Properties: {
+              GroupId: Template.ref(security_group),
+              CidrIp: cidr,
+              IpProtocol: protocol,
+              FromPort: from_port,
+              ToPort: to_port
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable Metrics/AbcSize
+        def self.instance(
+          scripts: nil,
+          script_variables: nil,
+          files: nil,
+          instance_profile:,
+          availability_zone:,
+          instance_type:,
+          key_name:,
+          subnet:,
+          name:,
+          wait_condition_handle:,
+          security_group:,
+          logical_id:,
+          source_dest_check:
+        )
+          files ||= {}
+          scripts.each_index do |index|
+            files["/tmp/formatron/script-#{index}.sh"] = {
+              content: scripts[index],
+              mode: '000755',
+              owner: 'root',
+              group: 'root'
+            }
+          end unless scripts.nil?
+          script_variables_content =
+            script_variables.reduce([]) do |content, (key, value)|
+              content.concat(["#{key}=", value, "\n"])
+            end unless script_variables.nil?
+          files['/tmp/formatron/script-variables'] = {
+            content: Template.join(*script_variables_content),
+            mode: '000644',
+            owner: 'root',
+            group: 'root'
+          } unless script_variables_content.nil?
+          {
+            Type: 'AWS::EC2::Instance',
+            Metadata: {
+              Comment1: 'Create setup scripts',
+              'AWS::CloudFormation::Init' => {
+                config: {
+                  files: files
+                }
+              }
+            },
+            Properties: {
+              IamInstanceProfile: Template.ref(instance_profile),
+              AvailabilityZone: Template.join(
+                Template.ref('AWS::Region'),
+                availability_zone
+              ),
+              ImageId: Template.find_in_map(
+                Template::REGION_MAP,
+                Template.ref('AWS::Region'),
+                'ami'
+              ),
+              SourceDestCheck: source_dest_check,
+              InstanceType: instance_type,
+              KeyName: key_name,
+              SubnetId: Template.ref(subnet),
+              SecurityGroupIds: [Template.ref(security_group)],
+              Tags: [{
+                Key: 'Name',
+                Value: name
+              }],
+              UserData: Template.base_64(
+                Template.join(
+                  # rubocop:disable Metrics/LineLength
+                  "#!/bin/bash -v\n",
+                  "function error_exit\n",
+                  "{\n",
+                  "  cfn-signal -e 1 -r \"$1\" '", Template.ref(wait_condition_handle), "'\n",
+                  "  exit 1\n",
+                  "}\n",
+                  "apt-get -y update\n",
+                  "apt-get -y install python-setuptools\n",
+                  "easy_install https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-latest.tar.gz\n",
+                  "export PATH=$PATH:/opt/aws/bin\n",
+                  'cfn-init --region ', Template.ref('AWS::Region'),
+                  '    -v -s ', Template.ref('AWS::StackName'), " -r #{logical_id} ",
+                  " || error_exit 'Failed to run cfn-init'\n",
+                  "for file in /tmp/formatron/script-*.sh; do\n",
+                  "  $file || error_exit \"failed to run Formatron setup script: $file\"\n",
+                  "done\n",
+                  "# If all went well, signal success\n",
+                  "cfn-signal -e $? -r 'Formatron instance configuration complete' '", Template.ref(wait_condition_handle), "'\n"
+                # rubocop:enable Metrics/LineLength
+                )
+              )
+            }
+          }
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/ParameterLists
+        # rubocop:enable Metrics/MethodLength
+      end
+      # rubocop:enable Metrics/ModuleLength
+    end
+  end
+end