sitefull-cloud 0.0.1

data/lib/sitefull-cloud/auth.rb

@@ -0,0 +1,41 @@
+require 'forwardable'
+
+module Sitefull
+  module Cloud
+    class Auth
+      extend Forwardable
+      def_delegators :@provider, :token_options, :authorization_url_options
+
+      def initialize(provider_type, options = {})
+        token_set = !options[:token].to_s.empty?
+        token(JSON.parse options[:token]) if token_set
+        @provider = provider_class(provider_type).new(options, token_set)
+      end
+
+      def authorization_url
+        token.authorization_uri(authorization_url_options)
+      end
+
+      def authorize!(code)
+        token.code = code
+        token.fetch_access_token!
+      end
+
+      def token(token_data = nil)
+        @token ||= Signet::OAuth2::Client.new(token_data.nil? ? token_options : token_data)
+      end
+
+      def credentials
+        token.refresh!
+        @credentials ||= @provider.credentials(token)
+      end
+
+      private
+
+      def provider_class(provider_type)
+        require "sitefull-cloud/auth/#{provider_type}"
+        Kernel.const_get "Sitefull::Auth::#{provider_type.capitalize}"
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/mock.rb

@@ -0,0 +1,9 @@
+module Sitefull
+  module Cloud
+    module Mock
+      def mocked?
+        Sitefull::Cloud.mocked
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/provider/amazon/networking.rb

@@ -0,0 +1,87 @@
+module Sitefull
+  module Provider
+    module Amazon
+      module Networking
+        TEMPLATE_TAG = 'SiteFull Deployment'.freeze
+        VPC_CIDR_BLOCK = '172.16.0.0/16'.freeze
+        SUBNET_CIDR_BLOCK = '172.16.1.0/24'.freeze
+
+        protected
+
+        def vpc
+          @vpc ||= connection.describe_vpcs.vpcs.reverse.find { |v| check_tags(v) } || create_vpc
+        end
+        alias setup_vpc vpc
+
+        def internet_gateway
+          @internet_gateway ||= connection.describe_internet_gateways.internet_gateways.reverse.find { |i| check_internet_gateway(i) } || create_internet_gateway
+        end
+        alias setup_internet_gateway internet_gateway
+
+        def route_table
+          @route_table ||= connection.describe_route_tables.route_tables.reverse.find { |rt| rt.vpc_id == vpc.vpc_id }
+        end
+
+        def security_group
+          @security_group ||= connection.describe_security_groups.security_groups.reverse.find { |sg| sg.vpc_id == vpc.vpc_id }
+        end
+
+        def subnet
+          @subnet ||= connection.describe_subnets.subnets.reverse.find { |sg| check_tags(sg) } || create_subnet
+        end
+
+        def setup_routing
+          add_routing unless check_tags(route_table)
+        end
+
+        def setup_security_group
+          add_security_group_rules unless check_tags(security_group)
+        end
+
+        private
+
+        def create_vpc
+          vpc = connection.create_vpc(cidr_block: VPC_CIDR_BLOCK).vpc
+          add_tags(vpc.vpc_id)
+          vpc
+        end
+
+        def check_internet_gateway(internet_gateway)
+          internet_gateway.attachments.map(&:vpc_id).include?(vpc.vpc_id)
+        end
+
+        def create_internet_gateway
+          internet_gateway = connection.create_internet_gateway.internet_gateway
+          add_tags(internet_gateway.internet_gateway_id) unless check_tags(internet_gateway)
+          connection.attach_internet_gateway(internet_gateway_id: internet_gateway.internet_gateway_id, vpc_id: vpc.vpc_id)
+          internet_gateway
+        end
+
+        def add_routing
+          connection.create_route(route_table_id: route_table.route_table_id, destination_cidr_block: '0.0.0.0/0', gateway_id: internet_gateway.internet_gateway_id)
+          add_tags(route_table.route_table_id)
+        end
+
+        def add_security_group_rules
+          connection.authorize_security_group_ingress(group_id: security_group.group_id, ip_protocol: 'tcp', from_port: 22, to_port: 22, cidr_ip: '0.0.0.0/0')
+          add_tags(security_group.group_id)
+        end
+
+        def create_subnet
+          subnet = connection.create_subnet(vpc_id: vpc.vpc_id, cidr_block: SUBNET_CIDR_BLOCK).subnet
+          add_tags(subnet.subnet_id) unless check_tags(subnet)
+          connection.modify_subnet_attribute(subnet_id: subnet.subnet_id, map_public_ip_on_launch: { value: true })
+          subnet
+        end
+
+        def add_tags(resource_id)
+          connection.create_tags resources: [resource_id], tags: [{ key: 'Name', value: TEMPLATE_TAG }]
+        end
+
+        def check_tags(resource)
+          resource.tags.map(&:value).include?(TEMPLATE_TAG)
+        end
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/provider/amazon.rb

@@ -0,0 +1,61 @@
+require 'sitefull-cloud/provider/amazon/networking'
+
+module Sitefull
+  module Provider
+    module Amazon
+      include Networking
+
+      REQUIRED_OPTIONS = [:role_arn].freeze
+      MACHINE_TYPES = %w(t2.nano t2.micro t2.small t2.medium t2.large m4.large m4.xlarge m4.2xlarge m4.4xlarge m4.10xlarge m3.medium m3.large m3.xlarge m3.2xlarge).freeze
+
+      DEFAULT_REGION = 'us-east-1'.freeze
+
+      def connection
+        @connection ||= ::Aws::EC2::Client.new(region: options[:region] || DEFAULT_REGION, credentials: credentials)
+      end
+
+      def regions
+        @regions ||= connection.describe_regions.regions.map { |r| OpenStruct.new(id: r.region_name, name: r.region_name) }
+      end
+
+      def machine_types(_)
+        MACHINE_TYPES.map { |mt| OpenStruct.new(id: mt, name: mt) }
+      end
+
+      def images(os)
+        # IMAGES[os.to_sym]
+        filters = [{ name: 'name', values: ["#{os}*", "#{os.downcase}*"] }, { name: 'is-public', values: ['true'] }, { name: 'virtualization-type', values: ['hvm'] }]
+        connection.describe_images(filters: filters).images.map { |i| OpenStruct.new(id: i.image_id, name: i.name) }
+      end
+
+      def create_network
+        setup_vpc
+        setup_internet_gateway
+        setup_routing
+        subnet.subnet_id
+      end
+
+      def create_key(name)
+        result = connection.create_key_pair(key_name: name)
+        OpenStruct.new(name: result.key_name, data: result.key_material)
+      end
+
+      def create_firewall_rules(_)
+        setup_security_group
+      end
+
+      # Uses http://docs.aws.amazon.com/sdkforruby/api/Aws/EC2/Client.html#run_instances-instance_method
+      def create_instance(deployment)
+        connection.run_instances(image_id: deployment.image, instance_type: deployment.machine_type, subnet_id: deployment.network_id, key_name: deployment.key_name, security_group_ids: [security_group.group_id], min_count: 1, max_count: 1).instances.first.instance_id
+      end
+
+      def valid?
+        connection.describe_regions(dry_run: true)
+      rescue ::Aws::EC2::Errors::DryRunOperation
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/provider/azure.rb

@@ -0,0 +1,47 @@
+module Sitefull
+  module Provider
+    module Azure
+      REQUIRED_OPTIONS = [:subscription_id].freeze
+
+      def connection
+        #       @connection ||= {
+        #         arm: ::Azure::ARM::Resources::ResourceManagementClient.new(credentials),
+        #         net: ::Azure::ARM::Network::NetworkResourceProviderClient.new(credentials),
+        #         compute: ::Azure::ARM::Compute::ComputeManagementClient.new(credentials)
+        #       }
+      end
+
+      def regions
+        ['us']
+      end
+
+      def machine_types(region)
+        ["machine-type-#{region}"]
+      end
+
+      def images(os)
+        ["image-region-#{os}"]
+      end
+
+      def create_network
+        'network_id'
+      end
+
+      def create_firewall_rules(network_id)
+        network_id
+      end
+
+      def create_key(key_name)
+        OpenStruct.new(name: key_name, data: {})
+      end
+
+      def create_instance(deployment)
+        deployment
+      end
+
+      def valid?
+        true
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/provider/base.rb

@@ -0,0 +1,21 @@
+module Sitefull
+  module Provider
+    module Base
+      def regions
+        []
+      end
+
+      def machine_types(*_args)
+        []
+      end
+
+      def images(*_args)
+        []
+      end
+
+      def valid?
+        false
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/provider/google.rb

@@ -0,0 +1,86 @@
+require 'google/apis/compute_v1'
+
+module Sitefull
+  module Provider
+    module Google
+      REQUIRED_OPTIONS = [:project_name].freeze
+
+      def connection
+        return @connection unless @connection.nil?
+
+        connection = ::Google::Apis::ComputeV1::ComputeService.new
+        connection.authorization = credentials
+        @connection = connection
+      end
+
+      def project_name
+        @project_name ||= options[:project_name]
+      end
+
+      def regions
+        @regions ||= connection.list_zones(project_name).items
+      end
+
+      def machine_types(zone)
+        @machine_types ||= connection.list_machine_types(project_name, zone).items
+      rescue ::Google::Apis::ClientError
+        []
+      end
+
+      def images(os)
+        @images ||= project_images(project_name) + project_images("#{os}-cloud")
+      end
+
+      def create_network
+        return network_id unless network_id.nil?
+
+        network = ::Google::Apis::ComputeV1::Network.new(name: 'sitefull-cloud', i_pv4_range: '172.16.0.0/16')
+        connection.insert_network(project_name, network).target_link
+      end
+
+      def create_firewall_rules(network_id)
+        create_firewall_rule(network_id, 'sitefull-ssh', '22')
+        create_firewall_rule(network_id, 'sitefull-http', '80')
+        create_firewall_rule(network_id, 'sitefull-https', '443')
+        network_id
+      end
+
+      def create_key(_name)
+        OpenStruct.new(name: :key_name, data: :key_material)
+      end
+
+      def create_instance(deployment)
+        instance = ::Google::Apis::ComputeV1::Instance.new(name: "sitefull-deployment-#{deployment.id}", machine_type: deployment.machine_type,
+                                                           disks: [{ boot: true, autoDelete: true, initialize_params: { source_image: deployment.image } }],
+                                                           network_interfaces: [{ network: deployment.network_id, access_configs: [{ name: 'default' }] }])
+        connection.insert_instance(project_name, deployment.region, instance).target_link
+      end
+
+      def valid?
+        regions.any?
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def project_images(project)
+        images = connection.list_images(project).items
+        images.nil? || images.empty? ? [] : images.reject { |r| !r.deprecated.nil? && r.deprecated.state == 'DEPRECATED' }
+      end
+
+      def create_firewall_rule(network_id, rule_name, port)
+        rule = ::Google::Apis::ComputeV1::Firewall.new(name: rule_name, source_ranges: ['0.0.0.0/0'], network: network_id, allowed: [{ ip_protocol: 'tcp', ports: [port] }])
+        connection.insert_firewall(project_name, rule)
+      rescue ::Google::Apis::ClientError
+        nil
+      end
+
+      def network_id
+        @network ||= connection.get_network(project_name, 'sitefull-cloud').self_link
+      rescue ::Google::Apis::ClientError
+        nil
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/provider/mock.rb

@@ -0,0 +1,41 @@
+module Sitefull
+  module Provider
+    module Mock
+      def regions
+        mock_list 'region'
+      end
+
+      def machine_types(_region)
+        mock_list 'machine-type'
+      end
+
+      def images(_os)
+        mock_list 'image'
+      end
+
+      def create_network
+        'network-id'
+      end
+
+      def create_key(name)
+        OpenStruct.new(name: name, data: 'key-data')
+      end
+
+      def create_firewall_rules(_)
+      end
+
+      def create_instance(_)
+        'instance-id'
+      end
+
+      def valid?
+        true
+      end
+
+      private
+      def mock_list(prefix)
+        Array.new(5) { |i| OpenStruct.new(id: "#{prefix}-id-#{i}", name: "#{prefix}-name-#{i}") }
+      end
+    end
+  end
+end

data/lib/sitefull-cloud/provider.rb

@@ -0,0 +1,44 @@
+module Sitefull
+  module Cloud
+    class Provider
+      include Mock
+      PROVIDERS = %w(amazon azure google)
+
+      attr_reader :type, :options
+
+      def initialize(type, options = {})
+        @options = options unless options.nil?
+        @type = type || 'base'
+        extend(provider_module)
+      end
+
+      class << self
+        def all_required_options
+          PROVIDERS.map { |type| required_options_for(type) }.flatten
+        end
+
+        def required_options_for(type)
+          provider_class(type).const_get(:REQUIRED_OPTIONS)
+        end
+
+        def provider_class(type)
+          require "sitefull-cloud/provider/#{type}"
+          Kernel.const_get "Sitefull::Provider::#{type.capitalize}"
+        end
+      end
+
+      protected
+
+      def credentials
+        @credentials ||= Sitefull::Cloud::Auth.new(type, options).credentials
+      end
+
+      private
+
+      def provider_module
+        return self.class.provider_class(:mock) if mocked?
+        @provider_module ||= self.class.provider_class(type)
+      end
+    end
+  end
+end