draw_cloud 0.0.1

data/README.md

@@ -0,0 +1,22 @@
+drawcloud
+=========
+
+Draw AWS CloudFormation configurations in Ruby
+
+
+Copyright and License
+=====================
+ 
+Copyright 2013 SweetSpot Diabetes Care, Inc.
+ 
+Licensed under the Apache License, Version 2.0 (the "License"); you
+may not use this work except in compliance with the License. You may
+obtain a copy of the License in the LICENSE file, or at:
+ 
+http://www.apache.org/licenses/LICENSE-2.0
+ 
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing
+permissions and limitations under the License.

data/lib/draw_cloud.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+#
+# Copyright:: Copyright (c) 2012, SweetSpot Diabetes Care, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this work except in compliance with the License. You may
+# obtain a copy of the License in the LICENSE file, or at:
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+
+module DrawCloud
+  def self.ref(object)
+    if object.respond_to? :ref
+      object.ref
+    elsif object.is_a? Symbol
+      resource_style(object)
+    elsif object.respond_to? :each_pair
+      object.each_with_object({}) {|(k,v),x| x[k] = DrawCloud.ref(v)}
+    else
+      object
+    end
+  end
+
+  def self.resource_style(str)
+    str.to_s.camelize
+  end
+
+  def self.resource_name(o)
+    if o.respond_to? :resource_name
+      o.resource_name
+    else
+      resource_style(o)
+    end
+  end
+
+  require_relative "draw_cloud/utilities"
+  require_relative "draw_cloud/locations"
+  require_relative "draw_cloud/base"
+  require_relative "draw_cloud/simple_ref"
+  require_relative "draw_cloud/join_func"
+  require_relative "draw_cloud/base64_func"
+  require_relative "draw_cloud/get_att_func"
+  require_relative "draw_cloud/configuration"
+  require_relative "draw_cloud/map"
+  require_relative "draw_cloud/parameter"
+  require_relative "draw_cloud/output"
+  require_relative "draw_cloud/vpc"
+  require_relative "draw_cloud/sns_topic"
+  require_relative "draw_cloud/security_group"
+  require_relative "draw_cloud/iam_policy"
+  require_relative "draw_cloud/iam_user"
+  require_relative "draw_cloud/iam_access_key"
+  require_relative "draw_cloud/subnet"
+  require_relative "draw_cloud/network_acl"
+  require_relative "draw_cloud/network_acl_entry"
+  require_relative "draw_cloud/route_table"
+  require_relative "draw_cloud/route_table_entry"
+  require_relative "draw_cloud/internet_gateway"
+  require_relative "draw_cloud/rds_instance"
+  require_relative "draw_cloud/rds_security_group"
+  require_relative "draw_cloud/wait_handle"
+  require_relative "draw_cloud/ec2_instance"
+  require_relative "draw_cloud/ec2_instance_template"
+  require_relative "draw_cloud/as_launch_configuration"
+  require_relative "draw_cloud/as_group"
+  require_relative "draw_cloud/elastic_ip"
+  require_relative "draw_cloud/network_interface"
+end

data/lib/draw_cloud/as_group.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+#
+# Copyright:: Copyright (c) 2012, SweetSpot Diabetes Care, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this work except in compliance with the License. You may
+# obtain a copy of the License in the LICENSE file, or at:
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+
+module DrawCloud
+  class ASGroup < Base
+    NOTIFY_EC2_INSTANCE_LAUNCH          = "autoscaling:EC2_INSTANCE_LAUNCH"
+    NOTIFY_EC2_INSTANCE_LAUNCH_ERROR    = "autoscaling:EC2_INSTANCE_LAUNCH_ERROR"
+    NOTIFY_EC2_INSTANCE_TERMINATE       = "autoscaling:EC2_INSTANCE_TERMINATE"
+    NOTIFY_EC2_INSTANCE_TERMINATE_ERROR = "autoscaling:EC2_INSTANCE_TERMINATE_ERROR"
+    NOTIFY_EC2_TEST_NOTIFICATION        = "autoscaling:TEST_NOTIFICATION"
+    ALL_NOTIFICATIONS = [ NOTIFY_EC2_INSTANCE_LAUNCH,
+                          NOTIFY_EC2_INSTANCE_LAUNCH_ERROR,
+                          NOTIFY_EC2_INSTANCE_TERMINATE,
+                          NOTIFY_EC2_INSTANCE_TERMINATE_ERROR,
+                          NOTIFY_EC2_TEST_NOTIFICATION ]
+    ALL_ERRORS = [ NOTIFY_EC2_INSTANCE_LAUNCH_ERROR,
+                   NOTIFY_EC2_INSTANCE_TERMINATE_ERROR ]
+    ALL_ACTIVITY = [ NOTIFY_EC2_INSTANCE_LAUNCH,
+                     NOTIFY_EC2_INSTANCE_LAUNCH_ERROR,
+                     NOTIFY_EC2_INSTANCE_TERMINATE,
+                     NOTIFY_EC2_INSTANCE_TERMINATE_ERROR ]
+
+    attr_accessor :name, :availability_zones, :cooldown, :launch_configuration_name, :max_size, :min_size, :desired_capacity, :tags, :vpc_zone_identifier, :notification_configuration
+    alias :subnets :vpc_zone_identifier
+    alias :launch_configuration :launch_configuration_name
+    alias :launch_configuration= :launch_configuration_name=
+    def initialize(name, options={}, &block)
+      @name = name
+      @availability_zones = options.fetch(:availability_zones, [])
+      @cooldown = options.fetch(:cooldown, nil)
+      @launch_configuration_name = options.fetch(:launch_configuration_name, nil)
+      @max_size = options.fetch(:max_size, nil)
+      @min_size = options.fetch(:min_size, nil)
+      @notification_configuration = options.fetch(:notification_configuration, nil)
+      @desired_capacity = options.fetch(:desired_capacity, nil)
+      @tags = options.fetch(:tags, [])
+      @vpc_zone_identifier = options.fetch(:vpc_zone_identifier, nil)
+      super(options, &block)
+    end
+
+    def as_group
+      self
+    end
+
+    def notify(topic_arn, notification_types)
+      self.notification_configuration = {:arn => topic_arn, :types => notification_types}
+    end
+
+    def vpc_zone_identifier=(subnets)
+      if subnets.all? {|s| s.respond_to? :availability_zone }
+        self.availability_zones = subnets.collect(&:availability_zone)
+      end
+      @vpc_zone_identifier = subnets
+    end
+    alias :subnets= :vpc_zone_identifier=
+
+    def load_into_config(config)
+      config.cf_add_resource resource_name, self
+      super(config)
+    end
+
+    def resource_name
+      resource_style(name) + "AS"
+    end
+
+    def to_h
+      h = {
+        "Type" => "AWS::AutoScaling::AutoScalingGroup",
+        "Properties" => {
+          "AvailabilityZones" => availability_zones.collect {|g| DrawCloud.ref(g) },
+          "LaunchConfigurationName" => DrawCloud.ref(launch_configuration_name),
+          "MaxSize" => max_size,
+          "MinSize" => min_size,
+          "Tags" => [], # FIXME
+        }
+      }
+      p = h["Properties"]
+      p["AvailabilityZones"] = DrawCloud.ref(availability_zones) if cooldown
+      p["Cooldown"] = DrawCloud.ref(cooldown) if cooldown
+      p["DesiredCapacity"] = DrawCloud.ref(desired_capacity) if desired_capacity
+      p["VPCZoneIdentifier"] = vpc_zone_identifier.collect {|z| DrawCloud.ref(z) }
+      p["NotificationConfiguration"] = {
+        "TopicARN" => DrawCloud.ref(self.notification_configuration[:arn]),
+        "NotificationTypes" => self.notification_configuration[:types],
+      } if self.notification_configuration
+
+      add_standard_properties(h)
+    end
+  end
+end

data/lib/draw_cloud/as_group.rb~

@@ -0,0 +1,54 @@
+# encoding: utf-8
+#
+# Copyright:: Copyright (c) 2012, SweetSpot Diabetes Care, Inc.
+# License::   All rights reserved
+#
+
+module DrawCloud
+  class ASGroup < Base
+    attr_accessor :name, :availability_zones, :cooldown, :launch_configuration_name, :max_size, :min_size, :desired_capacity, :tags, :vpc_zone_identifier
+    alias :instance_class :instance_type
+    alias :instance_class= :instance_type=
+    def initialize(name, options={}, &block)
+      @name = name
+      @image_id = options.fetch(:image_id, nil)
+      @instance_monitoring = options.fetch(:instance_monitoring, nil)
+      @instance_type = options.fetch(:instance_type, nil)
+      @kernel_id = options.fetch(:kernel_id, nil)
+      @key_name = options.fetch(:key_name, nil)
+      @ram_disk_id = options.fetch(:ram_disk_id, nil)
+      @security_groups = options.fetch(:security_groups, nil)
+      @user_data = options.fetch(:user_data, nil)
+      @tags = {}
+      super(options, &block)
+    end
+
+    def as_launch_configuration
+      self
+    end
+
+    def load_into_config(config)
+      config.cf_add_resource resource_name, self
+      super(config)
+    end
+
+    def to_h
+      h = {
+        "Type" => "AWS::AutoScaling::LaunchConfiguration",
+        "Properties" => {
+          "ImageId" => DrawCloud.ref(image_id),
+          "InstanceType" => DrawCloud.ref(instance_type),
+        }
+      }
+      p = h["Properties"]
+      p["InstanceMonitoring"] = DrawCloud.ref(instance_monitoring) if instance_monitoring
+      p["KernelId"] = DrawCloud.ref(kernel_id) if kernel_id
+      p["KeyName"] = DrawCloud.ref(key_name) if key_name
+      p["RamDiskId"] = DrawCloud.ref(ram_disk_id) if ram_disk_id
+      p["SecurityGroups"] = security_groups if security_groups
+      p["UserData"] = user_data if user_data
+      h["Metadata"] = DrawCloud.ref(metadata) unless metadata.nil? || metadata.empty?
+      add_standard_properties(h)
+    end
+  end
+end

data/lib/draw_cloud/as_launch_configuration.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+#
+# Copyright:: Copyright (c) 2012, SweetSpot Diabetes Care, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this work except in compliance with the License. You may
+# obtain a copy of the License in the LICENSE file, or at:
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+#
+
+module DrawCloud
+  class ASLaunchConfiguration < Base
+    attr_accessor :name, :image_id, :instance_monitoring, :instance_type, :kernel_id, :key_name, :ram_disk_id, :security_groups, :user_data, :metadata, :tags
+    alias :instance_class :instance_type
+    alias :instance_class= :instance_type=
+    alias :monitoring :instance_monitoring
+    alias :monitoring= :instance_monitoring=
+    def initialize(name, options={}, &block)
+      @name = name
+      @image_id = options.fetch(:image_id, nil)
+      @instance_monitoring = options.fetch(:instance_monitoring, nil)
+      @instance_type = options.fetch(:instance_type, nil)
+      @kernel_id = options.fetch(:kernel_id, nil)
+      @key_name = options.fetch(:key_name, nil)
+      @ram_disk_id = options.fetch(:ram_disk_id, nil)
+      @security_groups = options.fetch(:security_groups, nil)
+      @user_data = options.fetch(:user_data, nil)
+      super(options, &block)
+    end
+
+    def as_launch_configuration
+      self
+    end
+
+    def load_into_config(config)
+      config.cf_add_resource resource_name, self
+      super(config)
+    end
+
+    def resource_name
+      resource_style(name) + "LaunchConfig"
+    end
+
+    def to_h
+      h = {
+        "Type" => "AWS::AutoScaling::LaunchConfiguration",
+        "Properties" => {
+          "ImageId" => DrawCloud.ref(image_id),
+          "InstanceType" => DrawCloud.ref(instance_type),
+        }
+      }
+      p = h["Properties"]
+      p["InstanceMonitoring"] = DrawCloud.ref(instance_monitoring) if instance_monitoring
+      p["KernelId"] = DrawCloud.ref(kernel_id) if kernel_id
+      p["KeyName"] = DrawCloud.ref(key_name) if key_name
+      p["RamDiskId"] = DrawCloud.ref(ram_disk_id) if ram_disk_id
+      p["SecurityGroups"] = security_groups.collect {|s| DrawCloud.ref(s)} if security_groups
+      p["UserData"] = DrawCloud.ref(user_data) if user_data
+      h["Metadata"] = DrawCloud.ref(metadata) unless metadata.nil? || metadata.empty?
+      add_standard_properties(h)
+    end
+  end
+end

data/lib/draw_cloud/as_launch_configuration.rb~

@@ -0,0 +1,50 @@
+# encoding: utf-8
+#
+# Copyright:: Copyright (c) 2012, SweetSpot Diabetes Care, Inc.
+# License::   All rights reserved
+#
+
+module DrawCloud
+  class ASLaunchConfiguration < Base
+    attr_accessor :name, :image_id, :instance_monitoring, :instance_type, :kernel_id, :key_name, :ram_disk_id, :security_groups, :user_data
+    def initialize(name, cidr, options={}, &block)
+      @name = name
+      @cidr = cidr
+      @availability_zone = options.fetch(:availability_zone, nil)
+      @route_table = options.fetch(:route_table, nil)
+      @network_acl = options.fetch(:network_acl, nil)
+      super(options, &block)
+    end
+
+    def subnet
+      self
+    end
+
+    def load_into_config(config)
+      config.cf_add_resource resource_name, self
+      if route_table
+        route_table.load_into_config(config)
+        assoc = SubnetRouteTableAssociation.new(self, route_table)
+        config.cf_add_resource assoc.resource_name, assoc
+      end
+      if network_acl
+        network_acl.load_into_config(config)
+        assoc = SubnetNetworkAclAssociation.new(self, network_acl)
+        config.cf_add_resource assoc.resource_name, assoc
+      end
+      super(config)
+    end
+
+    def to_h
+      h = {
+        "Type" => "AWS::EC2::Subnet",
+        "Properties" => {
+          "CidrBlock" => cidr,
+        }
+      }
+      h["Properties"]["VpcId"] = DrawCloud.ref(vpc) if vpc
+      h["Properties"]["AvailabilityZone"] = DrawCloud.ref(@availability_zone) if @availability_zone
+      add_standard_properties(h)
+    end
+  end
+end

data/lib/draw_cloud/base.rb

@@ -0,0 +1,264 @@
+# encoding: utf-8
+#
+# Copyright:: Copyright (c) 2012, SweetSpot Diabetes Care, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this work except in compliance with the License. You may
+# obtain a copy of the License in the LICENSE file, or at:
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+#
+
+require "json"
+require "active_support/inflector"
+require "deep_merge"
+
+module DrawCloud
+  class Base
+    include Utilities
+    include Locations
+
+    attr_accessor( :mappings,
+                   :parameters,
+                   :resources,
+                   :outputs,
+
+                   :subnets,
+                   :route_tables,
+                   :network_acls,
+                   :security_groups,
+                   :iam_users,
+                   :iam_policies,
+                   :iam_access_keys,
+                   :gateways,
+                   :rdses,
+                   :elastic_ips,
+                   :network_interfaces,
+                   :wait_handles,
+                   :ec2_instances,
+                   :as_launch_configurations,
+                   :as_groups,
+                   :vpcs,
+                   :sns_topics,
+
+                   :depends_on,
+                   :deletion_policy,
+                   :metadata,
+
+                   :parent )
+
+    def initialize(options={}, &block)
+      @mappings = {}
+      @parameters = {}
+      @resources = {}
+      @outputs = {}
+
+      @subnets = []
+      @route_tables = []
+      @network_acls = []
+      @security_groups = []
+      @iam_users = []
+      @iam_policies = []
+      @iam_access_keys = []
+      @gateways = []
+      @rdses = []
+      @ec2_instances = []
+      @as_launch_configurations = []
+      @as_groups = []
+      @elastic_ips = []
+      @network_interfaces = []
+      @wait_handles = []
+      @vpcs = []
+      @sns_topics = []
+
+      @parent = options.fetch(:parent, nil)
+
+      self.instance_exec(self, &block) if block
+    end
+
+    def load_into_config(config)
+      [@mappings, @parameters, @resources, @outputs].each do |i|
+        i.each {|k,v| v.load_into_config(config)}
+      end
+
+      [@gateways, @subnets, @route_tables, @network_acls, @security_groups, @iam_users, @iam_policies, @iam_access_keys,
+       @rdses, @ec2_instances, @as_launch_configurations, @as_groups, @elastic_ips, @network_interfaces, @wait_handles, @vpcs, @sns_topics].each do |a|
+        a.each {|g| g.load_into_config(config) }
+      end
+    end
+
+    def resource_name
+      resource_style(name)
+    end
+
+    def add_standard_properties(hash)
+      hash["DependsOn"] = DrawCloud.resource_name(depends_on) if depends_on
+      hash["DeletionPolicy"] = DrawCloud.resource_style(deletion_policy) if deletion_policy
+      hash["Metadata"] = DrawCloud.ref(metadata) unless metadata.nil?
+      hash
+    end
+
+    def ref
+      {"Ref" => resource_name}
+    end
+
+    def [](attribute)
+      fngetatt(self, attribute)
+    end
+
+    ## Definers
+
+    def create_mapping(name, map_by_function, values={})
+      m = Map.new(name, map_by_function, {:parent => self}, values)
+      mappings[m.resource_name] = m
+      m
+    end
+
+    def create_output(name, options={}, &block)
+      o = Output.new(name, options.merge(:parent => self), &block)
+      outputs[o.resource_name] = o
+      o
+    end
+
+    def create_parameter(name, type, options={}, &block)
+      p = Parameter.new(name, type, options.merge(:parent => self), &block)
+      parameters[p.resource_name] = p
+      p
+    end
+
+    def create_service(name, options={}, &block)
+      # NOOP
+    end
+
+    def create_vpc(name, cidr, options={}, &block)
+      v = Vpc.new(name, cidr, options.merge(:parent => self), &block)
+      vpcs << v
+      v
+    end
+
+    def create_sns_topic(name, options={}, &block)
+      s = SNSTopic.new(name, options.merge(:parent => self), &block)
+      sns_topics << s
+      s
+    end
+
+    def create_subnet(name, cidr, options={}, &block)
+      # collisioncheck
+      s = Subnet.new(name, cidr, options.merge(:parent => self), &block)
+      subnets << s
+      s
+    end
+
+    def create_route_table(name, options={}, &block)
+      r = RouteTable.new(name, options.merge(:parent => self), &block)
+      route_tables << r
+      r
+    end
+
+    def create_network_acl(name, options={}, &block)
+      a = NetworkAcl.new(name, options.merge(:parent => self), &block)
+      network_acls << a
+      a
+    end
+
+    def create_security_group(name, description=nil, options={}, &block)
+      g = SecurityGroup.new(name, description, options.merge(:parent => self), &block)
+      security_groups << g
+      g
+    end
+
+    def create_iam_user(name, options={}, &block)
+      u = IAMUser.new(name, options.merge(:parent => self), &block)
+      iam_users << u
+      u
+    end
+
+    def create_iam_policy(name, options={}, &block)
+      p = IAMPolicy.new(name, options.merge(:parent => self), &block)
+      iam_policies << p
+      p
+    end
+
+    def create_iam_access_key(name, options={}, &block)
+      a = IAMAccessKey.new(name, options.merge(:parent => self), &block)
+      iam_access_keys << a
+      a
+    end
+
+    def create_rds(name, options={}, &block)
+      r = RDSInstance.new(name, options.merge(:parent => self), &block)
+      rdses << r
+      r
+    end
+
+    def create_ec2_instance_template(name, options={}, &block)
+      EC2InstanceTemplate.new(name, options.merge(:parent => self), &block)
+    end
+
+    def create_ec2_instance(name, options={}, &block)
+      e = EC2Instance.new(name, options.merge(:parent => self), &block)
+      ec2_instances << e
+      e
+    end
+
+    def create_as_launch_configuration(name, options={}, &block)
+      lc = ASLaunchConfiguration.new(name, options.merge(:parent => self), &block)
+      as_launch_configurations << lc
+      lc
+    end
+
+    def create_as_group(name, options={}, &block)
+      asg = ASGroup.new(name, options.merge(:parent => self), &block)
+      as_groups << asg
+      asg
+    end
+
+    def create_wait_handle(name, timeout=nil, options={}, &block)
+      h = WaitHandle.new(name, timeout, options.merge(:parent => self), &block)
+      wait_handles << h
+      h
+    end
+
+    def create_elastic_ip(name, options={}, &block)
+      eip = ElasticIp.new(name, options.merge(:parent => self), &block)
+      elastic_ips << eip
+      eip
+    end
+
+    def create_network_interface(name, options={}, &block)
+      eni = NetworkInterface.new(name, options.merge(:parent => self), &block)
+      network_interfaces << eni
+      eni
+    end
+
+    ## Accessors (list below so grep works)
+    # def elastic_ip
+    # def internet_gateway
+    # def network_acl
+    # def rds
+    # def route_table
+    # def security_group
+    # def subnet
+    # def vpc
+    [:elastic_ip, :network_interface, :ec2_instance, :as_launch_configuration, :as_group,
+     :internet_gateway, :network_acl, :rds, :route_table, :security_group,
+     :subnet, :vpc, :iam_user, :iam_policy, :iam_access_key].each do |accessor|
+      self.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{accessor}()
+          if parent
+            parent.#{accessor}
+          else
+            nil
+          end
+        end
+      RUBY_EVAL
+    end
+  end
+end