bosh-bootstrap 0.10.2 → 0.11.0

data/lib/bosh/providers/aws.rb

@@ -1,258 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-module Bosh; module Providers; end; end
-
-require "bosh/providers/base_provider"
-
-class Bosh::Providers::AWS < Bosh::Providers::BaseProvider
-  # supported by fog 1.6.0
-  # FIXME weird that fog has no method to return this list
-  def region_labels
-    ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'sa-east-1', 'us-east-1', 'us-west-1', 'us-west-2']
-  end
-
-  def default_region_label
-    'us-east-1'
-  end
-
-  # @return [Integer] megabytes of RAM for requested flavor of server
-  def ram_for_server_flavor(server_flavor_id)
-    if flavor = fog_compute_flavor(server_flavor_id)
-      flavor[:ram]
-    else
-      raise "Unknown AWS flavor '#{server_flavor_id}'"
-    end
-  end
-
-  # @return [Hash] e.g. { :bits => 0, :cores => 2, :disk => 0,
-  #   :id => 't1.micro', :name => 'Micro Instance', :ram => 613}
-  # or nil if +server_flavor_id+ is not a supported flavor ID
-  def fog_compute_flavor(server_flavor_id)
-    aws_compute_flavors.find { |fl| fl[:id] == server_flavor_id }
-  end
-
-  # @return [Array] of [Hash] for each supported compute flavor
-  # Example [Hash] { :bits => 0, :cores => 2, :disk => 0,
-  #   :id => 't1.micro', :name => 'Micro Instance', :ram => 613}
-  def aws_compute_flavors
-    Fog::Compute::AWS::FLAVORS
-  end
-
-  def aws_compute_flavor_ids
-    aws_compute_flavors.map { |fl| fl[:id] }
-  end
-
-  # Provision an EC2 or VPC elastic IP addess.
-  # * VPC - provision_public_ip_address(vpc: true)
-  # * EC2 - provision_public_ip_address
-  # @return [String] provisions a new public IP address in target region
-  # TODO nil if none available
-  def provision_public_ip_address(options={})
-    if options.delete(:vpc)
-      options[:domain] = "vpc"
-    else
-      options[:domain] = options.delete(:domain) || "standard"
-    end
-    address = fog_compute.addresses.create(options)
-    address.public_ip
-    # TODO catch error and return nil
-  end
-
-  def associate_ip_address_with_server(ip_address, server)
-    address = fog_compute.addresses.get(ip_address)
-    address.server = server
-  end
-
-  def create_vpc(name, cidr_block)
-    vpc = fog_compute.vpcs.create(name: name, cidr_block: cidr_block)
-    vpc.id
-  end
-
-  # Creates a VPC subnet
-  # @return [String] the subnet_id
-  def create_subnet(vpc_id, cidr_block)
-    subnet = fog_compute.subnets.create(vpc_id: vpc_id, cidr_block: cidr_block)
-    subnet.subnet_id
-  end
-
-  def create_internet_gateway(vpc_id)
-    gateway = fog_compute.internet_gateways.create(vpc_id: vpc_id)
-    gateway.id
-  end
-
-  # Creates or reuses an AWS security group and opens ports.
-  #
-  # +security_group_name+ is the name to be created or reused
-  # +ports+ is a hash of name/port for ports to open, for example:
-  # {
-  #   ssh: 22,
-  #   http: 80,
-  #   https: 443
-  # }
-  # protocol defaults to TCP
-  # You can also use a more verbose +ports+ using the format:
-  # {
-  #   ssh: 22,
-  #   http: { ports: (80..82) },
-  #   mosh: { protocol: "udp", ports: (60000..60050) }
-  #   mosh: { protocol: "rdp", ports: (3398..3398), ip_ranges: [ { cidrIp: "196.212.12.34/32" } ] }
-  # }
-  # In this example, 
-  #  * TCP 22 will be opened for ssh from any ip_range,
-  #  * TCP ports 80, 81, 82 for http from any ip_range,
-  #  * UDP 60000 -> 60050 for mosh from any ip_range and
-  #  * TCP 3398 for RDP from ip range: 96.212.12.34/32
-  def create_security_group(security_group_name, description, ports)
-    unless sg = fog_compute.security_groups.get(security_group_name)
-      sg = fog_compute.security_groups.create(name: security_group_name, description: description)
-      puts "Created security group #{security_group_name}"
-    else
-      puts "Reusing security group #{security_group_name}"
-    end
-    ip_permissions = sg.ip_permissions
-    ports_opened = 0
-    ports.each do |name, port_defn|
-      (protocol, port_range, ip_range) = extract_port_definition(port_defn)
-      unless port_open?(ip_permissions, port_range, protocol, ip_range)
-        sg.authorize_port_range(port_range, {:ip_protocol => protocol, :cidr_ip => ip_range})
-        puts " -> opened #{name} ports #{protocol.upcase} #{port_range.min}..#{port_range.max} from IP range #{ip_range}"
-        ports_opened += 1
-      end
-    end
-    puts " -> no additional ports opened" if ports_opened == 0
-    true
-  end
-
-  def port_open?(ip_permissions, port_range, protocol, ip_range)
-    ip_permissions && ip_permissions.find do |ip| 
-      ip["ipProtocol"] == protocol \
-      && ip["ipRanges"].detect { |range| range["cidrIp"] == ip_range } \
-      && ip["fromPort"] <= port_range.min \
-      && ip["toPort"] >= port_range.max
-    end
-  end
-
-  def find_server_device(server, device)
-    server.volumes.all.find {|v| v.device == device}
-  end
-
-  def create_and_attach_volume(name, disk_size, server, device)
-    volume = fog_compute.volumes.create(
-        size: disk_size,
-        name: name,
-        description: '',
-        device: device,
-        availability_zone: server.availability_zone)
-    # TODO: the following works in fog 1.9.0+ (but which has a bug in bootstrap)
-    # https://github.com/fog/fog/issues/1516
-    #
-    # volume.wait_for { volume.status == 'available' }
-    # volume.attach(server.id, "/dev/vdc")
-    # volume.wait_for { volume.status == 'in-use' }
-    #
-    # Instead, using:
-    volume.server = server
-  end
-
-  # Ubuntu 12.10 64bit (EBS) - Quantal
-  def quantal_image_id(region)
-    # http://cloud-images.ubuntu.com/quantal/current/
-    image_id = case region.to_s
-    when 'ap-northeast-1'
-      'ami-ccf270cd'
-    when 'ap-southeast-1'
-      'ami-16e8a444'
-    when 'ap-southeast-2'
-      'ami-5af36360'
-    when 'eu-west-1'
-      'ami-789c890c'
-    when 'sa-east-1'
-      'ami-35b36928'
-    when 'us-east-1'
-      'ami-1c80e475'
-    when 'us-west-1'
-      'ami-28567a6d'
-    when 'us-west-2'
-      'ami-5822b668'
-    end
-    image_id || raise("Please add Ubuntu 12.10 64bit (EBS) AMI image id to aws.rb#image_id method for region '#{region}'")
-  end
-
-  def bootstrap(new_attributes = {})
-    if new_attributes.delete(:quantal)
-      new_attributes[:image_id] ||= quantal_image_id(fog_compute.region)
-    end
-    vpc = new_attributes[:subnet_id]
-
-    server = fog_compute.servers.new(new_attributes)
-
-    unless new_attributes[:key_name]
-      raise "please provide :key_name attribute"
-    end
-    unless private_key_path = new_attributes.delete(:private_key_path)
-      raise "please provide :private_key_path attribute"
-    end
-
-    if vpc
-      # TODO setup security group on new server
-    else
-      # make sure port 22 is open in the first security group
-      security_group = fog_compute.security_groups.get(server.groups.first)
-      authorized = security_group.ip_permissions.detect do |ip_permission|
-        ip_permission['ipRanges'].first && ip_permission['ipRanges'].first['cidrIp'] == '0.0.0.0/0' &&
-        ip_permission['fromPort'] == 22 &&
-        ip_permission['ipProtocol'] == 'tcp' &&
-        ip_permission['toPort'] == 22
-      end
-      unless authorized
-        security_group.authorize_port_range(22..22)
-      end
-    end
-
-    server.save
-    server.wait_for { ready? }
-    server.setup(:keys => [private_key_path])
-    server
-  end
-
-  def servers_with_sg(sg_name)
-    inception_sg = fog_compute.security_groups.find {|sg| sg.name == sg_name }
-    if inception_sg
-      fog_compute.servers.select {|s| s.security_group_ids.include? inception_sg.group_id }
-    else
-      $stderr.puts "no security group #{sg_name} was found"
-      []
-    end
-  end
-
-  def delete_security_group_and_servers(sg_name)
-    sg = fog_compute.security_groups.find {|sg| sg.name == sg_name }
-    if sg
-      fog_compute.servers.select {|s| s.security_group_ids.include? sg.group_id }.each do |server|
-        puts "Destroying server #{server.id}..."
-        server.destroy
-      end
-      begin
-        puts "Destroying security group #{sg.name}..."
-        sg.destroy
-      rescue Fog::Compute::AWS::Error => e
-        $stderr.puts e
-      end
-    end
-  end
-
-  def delete_key_pair(kp_name)
-    if kp = fog_compute.key_pairs.find {|kp| kp.name == kp_name}
-      puts "Deleting key pair #{kp.name}..."
-      kp.destroy
-    end
-  end
-
-  # Destroy all IP addresses that aren't bound to a server
-  def cleanup_unused_ip_addresses
-    fog_compute.addresses.each do |a|
-      puts "Deleting IP address #{a.public_ip}..."
-      a.destroy unless a.server
-    end
-  end
-end

data/lib/bosh/providers/base_provider.rb

@@ -1,48 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-module Bosh; module Providers; end; end
-
-class Bosh::Providers::BaseProvider
-  attr_reader :fog_compute
-
-  def initialize(fog_compute)
-    @fog_compute = fog_compute
-  end
-
-  def create_key_pair(key_pair_name)
-    fog_compute.key_pairs.create(:name => key_pair_name)
-  end
-
-  def delete_key_pair_if_exists(key_pair_name)
-    if fog_key_pair = fog_compute.key_pairs.get(key_pair_name)
-      fog_key_pair.destroy
-    end
-  end
-
-  # Any of the following +port_defn+ can be used:
-  # {
-  #   ssh: 22,
-  #   http: { ports: (80..82) },
-  #   mosh: { protocol: "udp", ports: (60000..60050) }
-  #   mosh: { protocol: "rdp", ports: (3398..3398), ip_range: "196.212.12.34/32" }
-  # }
-  # In this example,
-  #  * TCP 22 will be opened for ssh from any ip_range,
-  #  * TCP ports 80, 81, 82 for http from any ip_range,
-  #  * UDP 60000 -> 60050 for mosh from any ip_range and
-  #  * TCP 3398 for RDP from ip range: 96.212.12.34/32
-  def extract_port_definition(port_defn)
-    protocol = "tcp"
-    ip_range = "0.0.0.0/0"
-    if port_defn.is_a? Integer
-      port_range = (port_defn..port_defn)
-    elsif port_defn.is_a? Range
-      port_range = port_defn
-    elsif port_defn.is_a? Hash
-      protocol = port_defn[:protocol] if port_defn[:protocol]
-      port_range = port_defn[:ports]  if port_defn[:ports]
-      ip_range = port_defn[:ip_range] if port_defn[:ip_range]
-    end
-    [protocol, port_range, ip_range]
-  end
-end

data/lib/bosh/providers/openstack.rb

@@ -1,79 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-module Bosh; module Providers; end; end
-
-require "bosh/providers/base_provider"
-
-class Bosh::Providers::OpenStack < Bosh::Providers::BaseProvider
-  # @return [String] provisions a new public IP address in target region
-  # TODO nil if none available
-  def provision_public_ip_address(options={})
-    address = fog_compute.addresses.create
-    address.ip
-    # TODO catch error and return nil
-  end
-
-  def associate_ip_address_with_server(ip_address, server)
-    address = fog_compute.addresses.find { |a| a.ip == ip_address }
-    address.server = server
-  end
-
-  # Creates or reuses an OpenStack security group and opens ports.
-  # 
-  # +security_group_name+ is the name to be created or reused
-  # +ports+ is a hash of name/port for ports to open, for example:
-  # {
-  #   ssh: 22,
-  #   http: 80,
-  #   https: 443
-  # }
-  def create_security_group(security_group_name, description, ports)
-    security_groups = fog_compute.security_groups
-    unless sg = security_groups.find { |s| s.name == security_group_name }
-      sg = fog_compute.security_groups.create(name: security_group_name, description: description)
-      puts "Created security group #{security_group_name}"
-    else
-      puts "Reusing security group #{security_group_name}"
-    end
-    ip_permissions = sg.rules
-    ports_opened = 0
-    ports.each do |name, port_defn|
-      (protocol, port_range, ip_range) = extract_port_definition(port_defn)
-      unless port_open?(ip_permissions, port_range, protocol, ip_range)
-        sg.create_security_group_rule(port_range.min, port_range.max, protocol, ip_range)
-        puts " -> opened #{name} ports #{protocol.upcase} #{port_range.min}..#{port_range.max} from IP range #{ip_range}"
-        ports_opened += 1
-      end
-    end
-    puts " -> no additional ports opened" if ports_opened == 0
-    true
-  end
-
-  def port_open?(ip_permissions, port_range, protocol, ip_range)
-    ip_permissions && ip_permissions.find do |ip|
-      ip["ip_protocol"] == protocol \
-      && ip["ip_range"].detect { |range| range["cidr"] == ip_range } \
-      && ip["from_port"] <= port_range.min \
-      && ip["to_port"] >= port_range.max
-    end
-  end
-
-  def find_server_device(server, device)
-    va = fog_compute.get_server_volumes(server.id).body['volumeAttachments']
-    va.find { |v| v["device"] == device }
-  end
-
-  def create_and_attach_volume(name, disk_size, server, device)
-    volume = fog_compute.volumes.create(:name => name,
-                                        :description => "",
-                                        :size => disk_size,
-                                        :availability_zone => server.availability_zone)
-    volume.wait_for { volume.status == 'available' }
-    volume.attach(server.id, device)
-    volume.wait_for { volume.status == 'in-use' }
-  end
-
-  def delete_security_group_and_servers(sg_name)
-    raise "not implemented yet"
-  end
-end

data/lib/bosh/providers.rb

@@ -1,21 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-module Bosh; end
-
-module Bosh::Providers
-  extend self
-  # returns a BOSH provider (CPI) specific object
-  # with helpers related to that provider
-  def for_bosh_provider_name(provider_name, fog_compute)
-    case provider_name.to_sym
-    when :aws
-      require "bosh/providers/aws"
-      Bosh::Providers::AWS.new(fog_compute)
-    when :openstack
-      require "bosh/providers/openstack"
-      Bosh::Providers::OpenStack.new(fog_compute)
-    else
-      raise "please support #{provider_name} provider"
-    end
-  end
-end