etude_for_aws 0.7.4

data/lib/etude_for_aws/vpc/vpc_api_gateway.rb

@@ -0,0 +1,277 @@
+module VPC
+  class VpcApiGateway
+    include CertificationHelper
+
+    attr_reader :ec2
+
+    def initialize
+      aws_certificate
+      @ec2 = Aws::EC2::Client.new
+      @stub = false
+    end
+
+    def stub?
+      @stub
+    end
+
+    def select_vpcs_by_name(name)
+      filter_tag_value = set_filter_tag_value(name)
+      @ec2.describe_vpcs(
+          {filters: [filter_tag_value], }
+      ).vpcs
+    end
+
+    def select_subnets_by_name(name)
+      filter_tag_value = set_filter_tag_value(name)
+      @ec2.describe_subnets(
+          {filters: [filter_tag_value], }
+      ).subnets
+    end
+
+    def select_internet_gateways_by_name(name)
+      filter_tag_value = set_filter_tag_value(name)
+      @ec2.describe_internet_gateways(
+          {filters: [filter_tag_value], }
+      ).internet_gateways
+    end
+
+    def select_route_tables_by_name(name)
+      filter_tag_value = set_filter_tag_value(name)
+      @ec2.describe_route_tables(
+          {filters: [filter_tag_value], }
+      ).route_tables
+    end
+
+    def select_associate_route_table_ids_by_route_table_id(route_table_id)
+      associate_route_table_ids = []
+      resp = @ec2.describe_route_tables({
+                                           route_table_ids: [
+                                               route_table_id,
+                                           ],
+                                       })
+      resp.route_tables.each do |route_table|
+        route_table.associations.each do |association|
+          associate_route_table_ids << association.route_table_association_id
+        end
+      end
+      associate_route_table_ids
+    end
+
+    def create_tags(resources,tags)
+      @ec2.create_tags(
+          resources:resources,
+          tags: tags
+      )
+    end
+
+    def create_vpc(vpc_name,vpc_cidr_block)
+      resp = @ec2.create_vpc({
+                                cidr_block: vpc_cidr_block
+                            }
+      )
+      vpc_id = resp.vpc.vpc_id
+      @ec2.wait_until(:vpc_exists, {vpc_ids: [vpc_id]})
+      vpc_id
+    end
+
+    def delete_vpc(vpc_id)
+      @ec2.delete_vpc({vpc_id: vpc_id})
+    end
+
+    def create_subnet(subnet_cidr_block,vpc_id,az)
+      resp = @ec2.create_subnet({
+                                   cidr_block: subnet_cidr_block,
+                                   vpc_id: vpc_id,
+                                   availability_zone: az,
+                               })
+      resp.subnet.subnet_id
+    end
+
+    def delete_subnet(subnet_id)
+      @ec2.delete_subnet({subnet_id: subnet_id})
+    end
+
+    def create_internet_gateway
+      resp = @ec2.create_internet_gateway
+      resp.internet_gateway.internet_gateway_id
+    end
+
+    def attach_internet_gateway(internet_gateway_id, vpc_id)
+      @ec2.attach_internet_gateway({
+                                       internet_gateway_id: internet_gateway_id,
+                                       vpc_id: vpc_id
+                                   })
+    end
+
+    def detach_internet_gateway(vpc_id,internet_gateway_id)
+      @ec2.detach_internet_gateway({
+                                      internet_gateway_id: internet_gateway_id,
+                                      vpc_id: vpc_id
+                                  })
+    end
+
+    def delete_internet_gateway(internet_gateway_id)
+      @ec2.delete_internet_gateway({internet_gateway_id: internet_gateway_id})
+    end
+
+    def create_route_table(vpc_id)
+      resp = @ec2.create_route_table({
+                                        vpc_id: vpc_id
+                                    })
+      resp.route_table.route_table_id
+    end
+
+    def create_route_public(destination_cidr_block,internet_gateway_id,route_table_id)
+      resp = @ec2.create_route({
+                                   destination_cidr_block: destination_cidr_block,
+                                   gateway_id: internet_gateway_id,
+                                   route_table_id: route_table_id,
+                        })
+      resp.return
+    end
+
+    def create_route_vpn(destination_cidr_block,vpc_gateway_id,route_table_id)
+      resp = @ec2.create_route({
+                                   destination_cidr_block: destination_cidr_block,
+                                   gateway_id: vpc_gateway_id,
+                                   route_table_id: route_table_id,
+                               })
+      resp.return
+    end
+
+    def create_route_private(destination_cidr_block,route_table_id)
+      resp = @ec2.create_route({
+                                   destination_cidr_block: destination_cidr_block,
+                                   route_table_id: route_table_id,
+                               })
+      resp.return
+    end
+
+    def associate_route_table(route_table_id,subnet_id)
+      resp = @ec2.associate_route_table({
+                                              route_table_id: route_table_id,
+                                              subnet_id: subnet_id,
+                                          })
+      resp.association_id
+    end
+
+    def disassociate_route_table(association_id)
+      ec2.disassociate_route_table({
+                                       association_id: association_id
+                                   })
+    end
+
+    def delete_route_table(route_table_id)
+      @ec2.delete_route_table({route_table_id: route_table_id})
+    end
+
+    def select_customer_gateways_by_name(name)
+      @ec2.describe_customer_gateways({
+                                          filters: [
+                                              {
+                                                  name: "tag-value",
+                                                  values: [name],
+                                              },
+                                          ],
+                                      }).customer_gateways
+    end
+
+    def select_vpc_gateways_by_name(name)
+      @ec2.describe_vpn_gateways({
+                                     filters: [
+                                         {
+                                             name: "tag-value",
+                                             values: [name],
+                                         },
+                                     ],
+                                 }).vpn_gateways
+    end
+
+    def select_vpn_connections_by_name(name)
+      @ec2.describe_vpn_connections({
+                                        filters: [
+                                            {
+                                                name: "tag-value",
+                                                values: [name],
+                                            },
+                                        ],
+                                    }).vpn_connections
+    end
+
+    def create_customer_gateway(bgp_asn,public_ip,type)
+      @ec2.create_customer_gateway({
+                                       bgp_asn: bgp_asn,
+                                       public_ip: public_ip,
+                                       type: type,
+                                   })
+    end
+
+    def delete_customer_gateway(customer_gateway_id)
+      @ec2.delete_customer_gateway({
+                                       customer_gateway_id: customer_gateway_id,
+                                   })
+    end
+
+    def create_vpn_gateway(type)
+      @ec2.create_vpn_gateway({
+                                  type: type
+                              })
+    end
+
+    def attach_vpn_gateway(vpn_gateway_id,vpc_id)
+      @ec2.attach_vpn_gateway({
+                                  vpn_gateway_id: vpn_gateway_id,
+                                  vpc_id: vpc_id,
+                              })
+    end
+
+    def detach_vpn_gateway(vpn_gateway_id,vpc_id)
+      @ec2.detach_vpn_gateway({
+                                  vpn_gateway_id: vpn_gateway_id,
+                                  vpc_id: vpc_id,
+                              })
+    end
+
+    def delete_vpn_gateway(vpn_gateway_id)
+      @ec2.delete_vpn_gateway({
+                                          vpn_gateway_id: vpn_gateway_id,
+                                      })
+    end
+
+    def create_vpn_connection(type,customer_gateway_id,vpn_gateway_id,static_routes_only)
+      @ec2.create_vpn_connection({
+                                                    type: type,
+                                                    customer_gateway_id: customer_gateway_id,
+                                                    vpn_gateway_id: vpn_gateway_id,
+                                                    options: {
+                                                        static_routes_only: static_routes_only,
+                                                    },
+                                                })
+    end
+
+    def delete_vpn_connection(vpn_connection_id)
+      @ec2.delete_vpn_connection({
+                                     vpn_connection_id: vpn_connection_id,
+                                 })
+    end
+
+    def wait_for_vpn_connection_available(vpn_connection_id)
+      @ec2.wait_until(:vpn_connection_available, {vpn_connection_ids: [vpn_connection_id]}) unless stub?
+    end
+
+
+    private
+    def set_filter_tag_value(name)
+      {
+          name: 'tag-value', values: [name]
+      }
+    end
+  end
+
+  class VpcApiGatewayStub < VpcApiGateway
+    def initialize
+      @ec2 = Aws::EC2::Client.new(stub_responses: true)
+      @stub = true
+    end
+  end
+end

data/lib/etude_for_aws/vpc/vpc_director.rb

@@ -0,0 +1,43 @@
+module VPC
+  class VpcDirector
+    attr_accessor :builder
+
+    def initialize(vpc_builder)
+      @builder = vpc_builder
+    end
+
+    def create
+      begin
+
+        @builder.create_vpc
+
+        @builder.create_subnets
+
+        @builder.create_internet_gateway
+
+        @builder.create_route_table
+
+      rescue Exception => e
+        puts "Error occurred (#{e.class})"
+        throw e
+      end
+    end
+
+    def destroy
+      begin
+
+        @builder.delete_route_tables
+
+        @builder.delete_internet_gateway
+
+        @builder.delete_subnets
+
+        @builder.delete_vpc
+
+      rescue Exception => e
+        puts "Error occurred (#{e.class})"
+        throw e
+      end
+    end
+  end
+end

data/lib/etude_for_aws/vpc/vpn.rb

@@ -0,0 +1,244 @@
+module VPC
+  class Vpn
+    attr_reader :vpc,
+                :customer_gateways,
+                :vpn_gateway,
+                :vpn_connections,
+                :route_tables,
+                :stub
+
+    def initialize(vpc)
+      @vpc = vpc
+      @config = vpc.config
+      @gateway = vpc.gateway
+      @route_tables = []
+      @vpc_tags = @config.get_yaml_vpc_tags
+      @stub = false
+
+      setup_customer_gateways
+      setup_vpn_gateway
+      setup_vpn_connections
+    end
+
+    def stub?
+      @stub
+    end
+
+    def create_customer_gateway
+      customer_gateways_info = @config.get_vpn_customer_gateways
+      customer_gateways_info.each do |customer_gateway_config|
+        customer_gateway_info = customer_gateway_config['CONFIG']['CUSTOMER_GATEWAY']
+        customer_gateway = CustomerGateway.new(@config,@gateway)
+        customer_gateway.create(customer_gateway_info)
+        @customer_gateways << customer_gateway
+      end
+    end
+
+    def create_vpn_gateway
+      vpn_gateway_info = @config.get_vpn_gateway
+      @vpn_gateway = VpnGateway.new(@config,@gateway)
+      @vpn_gateway.create(vpn_gateway_info)
+    end
+
+    def attach_vpn_gateway
+      @vpn_gateway.attach(@vpc.vpc_id)
+    end
+
+    def create_vpn_connection
+      n = 0
+      vpn_connections_info = @config.get_vpn_connections
+      vpn_connections_info.each do |vpn_connection_config|
+        vpn_connection_info = vpn_connection_config['CONFIG']['VPN_CONNECTION']
+        customer_gateway_id = @customer_gateways[n].customer_gateway_id
+        vpn_gateway_id = @vpn_gateway.vpn_gateway_id
+        vpn_connection = VpnConnection.new(@config,@gateway)
+        vpn_connection.creat(customer_gateway_id, vpn_gateway_id, vpn_connection_info)
+        @vpn_connections << vpn_connection
+        n += 1
+      end
+    end
+
+    def create_route
+      @vpn_connections.each do |vpn_connection|
+        vpn_connection_id = vpn_connection.vpn_connection_id
+        @gateway.wait_for_vpn_connection_available(vpn_connection_id)
+
+        @config.private_route_tables.each do |v|
+          name = v['CONFIG']['ROUTE_TABLE_TAGS'].first['NAME']['VALUE']
+          destination_cidr_blocks = @config.get_vpn_gateway['DESTINATION_CIDR_BLOCKS']
+          destination_cidr_blocks.each do |cidr_block|
+            route_tables = @gateway.select_route_tables_by_name(name)
+            route_tables.each do |route_table|
+              @gateway.create_route_vpn(cidr_block['CIDR'],@vpn_gateway.vpn_gateway_id,route_table.route_table_id)
+              @route_tables << route_table
+            end
+          end
+        end
+      end
+    end
+
+    def delete_customer_gateway
+      resp = []
+      @customer_gateways.each do |customer_gateway|
+        resp << customer_gateway.delete
+      end
+      @customer_gateways = []
+      @customer_gateways = resp
+    end
+
+    def delete_vpn_gateway
+      @vpn_gateway = @vpn_gateway.delete
+    end
+
+    def detach_vpn_gateway
+      @vpn_gateway.detach(@vpc.vpc_id)
+    end
+
+    def delete_vpn_connection
+      resp = []
+      @vpn_connections.each do |vpn_connection|
+        resp << vpn_connection.delete
+      end
+      @vpn_connections = []
+      @vpn_connections = resp
+    end
+
+    def delete_route
+      @route_tables.each do |route_table|
+        route_table_id = route_table.route_table_id
+        @associate_route_table_ids = @gateway.select_associate_route_table_ids_by_route_table_id(route_table_id)
+        @associate_route_table_ids.each do |id|
+          @gateway.disassociate_route_table(id)
+        end
+        @gateway.delete_route_table(route_table_id)
+      end
+    end
+
+    private
+    def setup_customer_gateways
+      @customer_gateways = []
+      customer_gateways_info = @config.get_vpn_customer_gateways
+      customer_gateways_info.each do |customer_gateway_config|
+        tags = customer_gateway_config['CONFIG']['CUSTOMER_GATEWAY']['TAGS']
+        value = tags['NAME']['VALUE']
+        customer_gateways = @gateway.select_customer_gateways_by_name(value)
+        unless customer_gateways.empty?
+          customer_gateway_id = customer_gateways[0].customer_gateway_id
+          @customer_gateways << CustomerGateway.new(@config, @gateway, customer_gateway_id)
+        end
+      end
+    end
+
+    def setup_vpn_gateway
+      value = @config.get_vpn_gateway['TAGS']['NAME']['VALUE']
+      vpn_gateways = @gateway.select_vpc_gateways_by_name(value)
+      unless vpn_gateways.empty?
+        vpn_gateway_id = vpn_gateways[0].vpn_gateway_id
+        @vpn_gateway = VpnGateway.new(@config,@gateway,vpn_gateway_id)
+      end
+    end
+
+    def setup_vpn_connections
+      @vpn_connections = []
+      vpn_connections_info = @config.get_vpn_connections
+      vpn_connections_info.each do |vpn_connection_config|
+        tags = vpn_connection_config['CONFIG']['VPN_CONNECTION']['TAGS']
+        value = tags['NAME']['VALUE']
+        vpn_connections = @gateway.select_vpn_connections_by_name(value)
+
+        unless vpn_connections.empty?
+          vpn_connection_id = vpn_connections[0].vpn_connection_id
+          vpn_connection = VpnConnection.new(@config, @gateway, vpn_connection_id)
+          @vpn_connections << vpn_connection
+        end
+      end
+    end
+  end
+
+  class VpnStub < Vpn
+    def initialize(vpc)
+      super
+      @stub = true
+    end
+
+    def delete_customer_gateway
+      @gateway.ec2.stub_responses(:describe_customer_gateways,
+                                     {
+                                         customer_gateways: [
+                                             {
+                                                 customer_gateway_id: 'String',
+                                                 tags: [
+                                                     {
+                                                         key:'Name',
+                                                         value: 'TestCustomerGateway'
+                                                     }
+                                                 ]
+                                             }
+                                         ]
+                                     })
+      super
+    end
+
+    def delete_virtual_gateway
+      @gateway.ec2.stub_responses(:describe_vpn_gateways,
+                                  {
+                                      vpn_gateways: [
+                                          {
+                                              vpn_gateway_id: 'String',
+                                              tags: [
+                                                  {
+                                                      key:'Name',
+                                                      value: 'TestVpnGateway'
+                                                  }
+                                              ]
+                                          }
+                                      ]
+                                  })
+
+      super
+    end
+
+    def detach_vpn_gateway
+      @gateway.ec2.stub_responses(:describe_vpn_gateways,
+                                  {
+                                      vpn_gateways: [
+                                          {
+                                              vpn_gateway_id: 'String',
+                                              tags: [
+                                                  {
+                                                      key:'Name',
+                                                      value: 'TestVpnGateway'
+                                                  }
+                                              ]
+                                          }
+                                      ]
+                                  })
+
+      super
+    end
+
+    def delete_vpn_connection
+      @gateway.ec2.stub_responses(:describe_vpn_connections,
+                                  {
+                                      vpn_connections: [
+                                          {
+                                              vpn_connection_id: 'String',
+                                              tags: [
+                                                  {
+                                                      key:'Name',
+                                                      value: 'TestVpnGateway'
+                                                  }
+                                              ]
+                                          }
+                                      ]
+                                  })
+
+      super
+    end
+
+    def delete_route
+      super
+      @route_tables = []
+    end
+  end
+end