kumogata-template 0.0.1

data/lib/kumogata/template/ec2.rb

@@ -0,0 +1,165 @@
+#
+# Helper - EC2
+#
+require 'kumogata/template/helper'
+
+def _ec2_tags(args)
+  if args.key? :tags_append
+    tags_append = {}
+    tags_append[:ref_domain] = "domain" unless args[:tags_append].key? :domain
+    tags_append[:ref_role] = "role" unless args[:tags_append].key? :role
+    tags_append.merge!(args[:tags_append])
+    args[:tags_append] = tags_append
+  else
+    args[:tags_append] = {
+      ref_domain: "domain",
+      ref_role: "role"
+    }
+  end
+  _tags(args)
+end
+
+def _ec2_security_group_egresses(name, args)
+  return [] unless args.key? name.to_sym
+
+  rules = []
+  _array(args[name.to_sym]).each do |arg|
+    rules << _ec2_security_group_egress(arg)
+  end
+  rules
+end
+
+def _ec2_security_group_egress(args)
+  cidr = args[:cidr] || "0.0.0.0/0"
+  destination = _ref_string("destination", args, "security group")
+  from = _ref_string("from", args)
+  group = _ref_string("group", args, "security group")
+  ip = args[:ip_protocol] || "tcp"
+  to = _ref_string("to", args)
+  from = to if from.empty?
+
+  _{
+    CidrIp cidr if destination.empty?
+    DestinationSecurityGroupId destination unless destination.empty?
+    FromPort from unless ip == "icmp"
+    GroupId group unless group.empty?
+    IpProtocol ip
+    ToPort to unless ip == "icmp"
+  }
+end
+
+def _ec2_security_group_ingresses(name, args)
+  return [] unless args.key? name.to_sym
+
+  rules = []
+  _array(args[name.to_sym]).each do |arg|
+    rules << _ec2_security_group_ingress(arg)
+  end
+  rules
+end
+
+def _ec2_security_group_ingress(args)
+  cidr = args[:cidr] || "0.0.0.0/0"
+  from = _ref_string("from", args)
+  group_id = _ref_string("group", args, "security group")
+  group_name = args[:group_name] || ""
+  ip = args[:ip_protocol] || "tcp"
+  source_group_name = _ref_string("source_group_name", args, "security group")
+  source_group_id = _ref_string("source_group_id", args, "security group")
+  source_group_owner_id = _ref_string("source_group_owner_id", args, "account id")
+  to = _ref_string("to", args)
+  to = from if to.empty?
+
+  _{
+    CidrIp cidr if source_group_name.empty? and source_group_id.empty?
+    FromPort from unless ip == "icmp"
+    GroupId group_id unless group_id.empty?
+    GroupName group_name unless group_name.empty?
+    IpProtocol ip
+    SourceSecurityGroupName source_group_name unless source_group_name.empty?
+    SourceSecurityGroupId source_group_id unless source_group_id.empty?
+    SourceSecurityGroupOwnerId source_group_name unless source_group_owner_id.empty?
+    ToPort to unless ip == "icmp"
+  }
+end
+
+def _ec2_block_device(args)
+  device = args[:device] || "/dev/sda1"
+  delete = _bool("delete", args, true)
+  encrypted = _bool("encrypted", args, false)
+  iops = args[:iops] || 300
+  snapshot = args[:snapshot] || ""
+  size = _ref_string("size", args, "volume size")
+  type = _valid_values(args[:type], %w( io1 gp2 sc1 st1 ), "gp2")
+  no_device = args[:no_device] || ""
+  virtual = args[:virtual] || ""
+
+  _{
+    DeviceName device
+    Ebs do
+      DeleteOnTermination delete
+      Encrypted encrypted if encrypted == true
+      Iops iops if type == "io1"
+      SnapshotId snapshot if device.empty?
+      VolumeSize size if snapshot.empty? and !size.empty?
+      VolumeType type
+    end
+    NoDevice no_device unless no_device.empty?
+    VirtualName virtual unless virtual.empty?
+  }
+end
+
+def _ec2_network_interface(args)
+  associate_public = _bool("associate_public", args, true)
+  delete = _bool("delete", args, true)
+  description = args[:description] || ""
+  device = args[:device] || 0
+  group_set = _ref_array("group_set", args, "security group")
+  network_interface = _ref_string("network", args)
+  private_ip = args[:private_ip] || ""
+  private_ips = args[:private_ips] || ""
+  secondary_private_ip = args[:secondary_private_ip] || ""
+  subnet = _ref_string("subnet", args, "subnet")
+
+  _{
+    AssociatePublicIpAddress associate_public
+    DeleteOnTermination delete
+    Description description unless description.empty?
+    DeviceIndex device
+    GroupSet group_set unless group_set.empty?
+    NetworkInterfaceId network_interface unless network_interface.empty?
+    PrivateIpAddress private_ip unless private_ip.empty?
+    PrivateIpAddresses private_ips unless private_ips.empty?
+    SecondaryPrivateIpAddressCount secondary_private_ip unless secondary_private_ip.empty?
+    SubnetId subnet
+  }
+end
+
+def _ec2_image(instance_type, args)
+  return args[:image_id] if args.key? :image_id
+  resource_image = _resource_name(args[:image] || EC2_DEFAULT_IMAGE)
+  _find_in_map("AWSRegionArch2AMI#{resource_image}",
+               _{ Ref "AWS::Region" },
+               _find_in_map("AWSInstanceType2Arch", instance_type, "Arch"))
+end
+
+def _ec2_port_range(args)
+  _{
+    From args[:from] || 0
+    To args[:to] || args[:from] || 65535
+  }
+end
+
+def _ec2_protocol_number(protocol)
+  # http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml
+  case protocol
+  when 'tcp'
+    6
+  when 'udp'
+    17
+  when 'icmp'
+    1
+  else
+    -1
+  end
+end

data/lib/kumogata/template/ecs.rb

@@ -0,0 +1,119 @@
+#
+# Helper - ECS
+#
+require 'kumogata/template/helper'
+
+def _ecs_load_balancers(args)
+  balancers = args[:load_balancers] || []
+
+  array = []
+  balancers.each do |balancer|
+    array << _{
+      ContainerName balancer[:container_name] || 80
+      ContainerPort balancer[:container_port] || 80
+      LoadBalancerName balancer[:lb_name] || ""
+    }
+  end
+  array
+end
+
+def _ecs_container_definitions(args)
+  definitions = args[:container_definitions] || []
+
+  array = []
+  definitions.each do |definition|
+    command = definition[:command] || []
+    entry_point = definition[:entry_point] || []
+    environment = definition[:environment] || []
+    links = definition[:link] || []
+    mount_points = _ecs_mount_points(definition)
+    port_mappings =
+      if definition.key? :port_mappings
+        if definition[:port_mappings].nil?
+          []
+        else
+          _ecs_port_mappings(definition)
+        end
+      else
+        _ecs_port_mappings({ port_mappings: [ { container_port: 80 } ] })
+      end
+    volumes_from = _ecs_volumes_from(definition)
+    array << _{
+      Command command unless command.empty?
+      Cpu definition[:cpu] || 10
+      EntryPoint entry_point unless entry_point.empty?
+      Environment environment unless environment.empty?
+      Essential _bool("essential", definition, true)
+      Image definition[:image]   # repository-url/image:tag
+      Links links unless links.empty?
+      Memory definition[:memory] || 300  # MiB
+      MountPoints mount_points unless mount_points.empty?
+      Name _ref_string("name", definition)
+      PortMappings port_mappings unless port_mappings.empty?
+      VolumesFrom volumes_from unless volumes_from.empty?
+    }
+  end
+  array
+end
+
+def _ecs_mount_points(args)
+  mount_points = args[:mount_points] || []
+  array = []
+  mount_points.each do |point|
+    array << _{
+      ContainerPath point[:container_path]
+      SourceVolume point[:source_volume]
+      ReadOnly _bool("read_only", point, false)
+    }
+  end
+  array
+end
+
+def _ecs_port_mappings(args)
+  port_mappings = args[:port_mappings] || []
+
+  array = []
+  port_mappings.each do |point|
+    host_port = _ref_string("host_port", point, "host port")
+    array << _{
+      ContainerPort _ref_string("container_port", point, "container port")
+      HostPort host_port unless host_port.empty?
+    }
+  end
+  array
+end
+
+def _ecs_volumes_from(args)
+  volumes_from = args[:volumes_from] || []
+
+  array = []
+  volumes_from.each do |volume|
+    array << _{
+      SourceContainer _ref_string("source", volume)
+      ReadOnly _bool("read_only", volume, false)
+    }
+  end
+  array
+end
+
+def _ecs_volumes(args)
+  volumes = args[:volumes] || []
+
+  array = []
+  volumes.each do |volume|
+    host = _ecs_volumes_host(volume[:host])
+    array << _{
+      Name volume[:name]
+      Host host unless host.empty?
+    }
+  end
+  array
+end
+
+def _ecs_volumes_host(args)
+  return {} if args.nil? or !args.key? :source_path
+
+  _{
+    SourcePath args[:source_path]
+  }
+end

data/lib/kumogata/template/elasticbeanstalk.rb

@@ -0,0 +1,33 @@
+#
+# Helper - Elasticbeanstalk
+#
+require 'kumogata/template/helper'
+
+def _elasticbeanstalk_option(options)
+  array = []
+  options.each do |option|
+    array << _{
+      Namespace option[:namespace]
+      OptionName option[:option]
+      Value option[:value]
+    }
+  end
+  array
+end
+
+def _elasticbeanstalk_configuration(configuration)
+  _{
+    ApplicationName configuration[:application]
+    TemplateName configuration[:template]
+  }
+end
+
+def _elasticbeanstalk_tier(tier)
+  name = _valid_values(tier[:name], %w( WebServer Worker ), "WebServer")
+
+  _{
+    Name name
+    Type (name == "WebServer") ? "Standard" : "SQS/HTTP"
+    Version tier[:version] || "1.0"
+  }
+end

data/lib/kumogata/template/elb.rb

@@ -0,0 +1,132 @@
+#
+# Helper - ELB
+#
+require 'kumogata/template/helper'
+
+def _elb_access_logging_policy(args)
+  access = args[:access_logging] || ""
+  return "" if access.empty?
+
+  _{
+    EmitInterval access[:emit] || 5
+    Enabled _bool("enabled", access, true)
+    S3BucketName access[:s3_bucket]
+    S3BucketPrefix access[:s3_bucket_prefix]
+  }
+end
+
+def _elb_app_cookie_stickiness_policy(args)
+  array = []
+  apps = args[:app_cookie] || []
+
+  apps.each do |app|
+    array << _{
+      CookieName app[:cookie]
+      PolicyName app[:policy]
+    }
+  end
+  array
+end
+
+def _elb_connection_draining_policy(args)
+  connection = args[:connection_draining] || {}
+
+  _{
+    Enabled _bool("enabled", connection, true)
+    Timeout connection[:timeout] || 60
+  }
+end
+
+def _elb_connection_settings(args)
+  connection = args[:connection_settings] || {}
+
+  _{
+    IdleTimeout connection[:idle] || 60
+  }
+end
+
+def _elb_health_check(args)
+  health_check = args[:health_check] || {}
+  protocol = _valid_values(health_check[:protocol], %w( http https tcp ssl ), "http")
+  port = health_check[:port] || case protocol
+                            when "http"
+                              80
+                            when "https"
+                              443
+                            end
+  path = health_check[:path] || "index.html"
+  _{
+    HealthyThreshold health_check[:healthy] || 10
+    Interval health_check[:interval] || 30
+    Target "#{protocol.upcase}:#{port}/#{path}"
+    Timeout health_check[:timeout] || 5
+    UnhealthyThreshold health_check[:unhealthly] || 2
+  }
+end
+
+def _elb_cookie_stickiness_policy(args)
+  cookies = args[:cookie_stickiness] || []
+
+  array = []
+  cookies.each do |cookie|
+    array << _{
+      CookieExpirationPeriod cookie[:expiration]
+      PolicyName cookie[:policy]
+    }
+  end
+  array
+end
+
+def _elb_listeners(args)
+  listeners = args[:listeners] || []
+  listeners = [ { protocol: "http" } ] if listeners.empty?
+
+  array = []
+  listeners.each do |listener|
+    proto = listener[:protocol].upcase
+    protocol = _valid_values(proto, %w( http https tcp ssl ), "http")
+    port = listener[:port] || case protocol
+                              when "http"
+                                80
+                              when "https"
+                                443
+                              end
+    lb_port = listener[:lb_port] || port
+    policies = []
+    policies << "ELBSecurityPolicy-2015-05" if protocol == "https" or protocol == "ssl"
+    ssl = _ref_string("ssl", listener)
+
+    array << _{
+      InstancePort port
+      InstanceProtocol protocol.upcase
+      LoadBalancerPort lb_port
+      PolicyNames policies unless policies.empty?
+      Protocol protocol.upcase
+      SSLCertificateId ssl if protocol == "https"
+    }
+  end
+  array
+end
+
+def _elb_policy_types(args)
+  policies = args[:policy] || []
+  return [] if policies.empty?
+
+  array = []
+  policies.each do |policy|
+    attributes = []
+    instance_ports = []
+    lb_ports = []
+    policy_name = policy[:name]
+    policy_type = policy[:type]
+
+    array << _{
+      Attributes attributes unless attributes.empty?
+      InstancePorts instance_ports unless instance_ports.empty?
+      LoadBalancerPorts lb_ports unless lb_ports.empty?
+      PolicyName policy_name
+      PolicyType policy_type
+    }
+  end
+  array
+end