kumogata-template 0.0.35 → 0.0.36

data/lib/kumogata/template/ecs.rb

@@ -3,134 +3,299 @@
 #
 require 'kumogata/template/helper'
 
+def _ecs_to_log_option(args)
+  option =
+    case args[:driver]
+    when "awslogs"
+      _ecs_to_log_option_awslogs(args)
+    when "fluentd"
+      _ecs_to_log_option_fluentd(args)
+    when "syslog"
+      _ecs_to_log_option_syslog(args)
+    when "json"
+      _ecs_to_log_option_syslog(args)
+    when "splunk"
+      _ecs_to_log_option_splunk(args)
+    when "gelf"
+      _ecs_to_log_option_gelf(args)
+    else
+      {}
+    end
+  option.merge(_ecs_to_log_option_common(args))
+end
+
+def _ecs_to_log_option_awslogs(args)
+  {
+    "awslogs-group": args[:group],
+    "awslogs-region": args[:region] || _region,
+    "awslogs-stream-prefix": args[:prefix] || "",
+  }
+end
+
+def _ecs_to_log_option_fluentd(args)
+  option = {
+    "fluentd-address": args[:address] || "localhost:24224",
+    "fluentd-retry-wait": args[:retry_wait] || 1,
+    "fluentd-max-retries": args[:max_retries] || 10,
+  }
+  option["fluentd-async-connect"] = true if args.key? :async
+  option["fluentd-buffer-limit"] = args[:buffer_limit] if args.key? :buffer_limit
+  option
+end
+
+def _ecs_to_log_option_syslog(args)
+  option = {
+    "syslog-address": args[:address],
+  }
+  option["syslog-facility"] = args[:facility] if args.key? :facility
+  option["syslog-tls-ca-cert"] = args[:ca_cert] if args.key? :ca_cert
+  option["syslog-tls-cert"] = args[:cert] if args.key? :cert
+  option["syslog-tls-key"] = args[:key] if args.key? :key
+  option["syslog-tls-skip-verify"] = true if args.key? :skip_verify
+  option["syslog-format"] = args[:format] if args.key? :format
+  option
+end
+
+def _ecs_to_log_option_json(args)
+  option = {
+    "max-size": args[:max_size] || "10m",
+    "max-file": args[:max_file] || 1,
+  }
+  option
+end
+
+def _ecs_to_log_option_splunk(args)
+  option = {
+    "splunk-token": args[:token],
+    "splunk-url": args[:url],
+    "splunk-verify-connection": _bool("veriy_connection", args, true),
+    "splunk-gzip": _bool("gzip", args, false),
+  }
+  option["splunk-source"] = args[:source] if args.key? :source
+  option["splunk-sourcetype"] = args[:source_type] if args.key? :source_type
+  option["splunk-index"] = args[:index] if args.key? :index
+  option["splunk-capath"] = args[:capath] if args.key? :capath
+  option["splunk-caname"] = args[:caname] if args.key? :caname
+  option["splunk-insecureskipverify"] = true if args.key? :skip_verify
+  option["splunk-format"] = args[:format] if args.key? :format
+  option["splunk-gzip-level"] = args[:gzip_level] if args.key? :gzip_label
+  option
+end
+
+def _ecs_to_log_option_gelf(args)
+  option = {
+    "gelf-address": args[:address],
+    "gelf-compression-type": args[:type] || "gzip",
+  }
+  option["gelf-compression-level"] = args[:level] if args.key? :level
+  option
+end
+
+def _ecs_to_log_option_common(args)
+  option = {}
+  option[:labels] = args[:labels].join(',') if args.key? :labels
+  option[:env] = args[:envs].join(',') if args.key? :envs
+  option["env-regex"] = args[:env_regex] if args.key? :env_regex
+  option[:tag] = args[:tag] if args.key? :tag
+  option
+end
+
+def _ecs_volumes(args)
+  (args[:volumes] || []).collect do |volume|
+    volume = { volume: "" } if volume.is_a? String
+    volume.map.collect do |name, source|
+      _{
+        Name name
+        Host do
+          SourcePath source
+        end unless source.empty?
+      }
+    end
+  end.flatten
+end
+
 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] || ""
+  (args[:load_balancers] || []).collect do |balancer|
+    target = _ref_string('target', balancer, 'target group')
+
+    _{
+      ContainerName _name("name", balancer)
+      ContainerPort balancer[:port] || 80
+      LoadBalancerName _name("lb_name", balancer) if target.empty?
+      TargetGroupArn target unless target.empty?
     }
   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
+end
+
+def _ecs_network(args)
+  vpc = args[:vpc] || []
+  return vpc if vpc.empty?
+
+  vpc = _ecs_vpc(vpc)
+
+  _{
+    AwsvpcConfiguration vpc
+  }
+end
+
+def _ecs_vpc(args)
+  assign_public = _bool('assign_public', args, false)
+  security_groups = _ref_array('security_groups', args, 'security group')
+  subnets = _ref_array('subnets', args, 'subnets')
+
+  _{
+    AssignPublicIp assign_public ? 'ENABLED' : 'DISABLED'
+    SecurityGroups security_groups unless security_groups.empty?
+    Subnets subnets
+  }
+end
+
+def _ecs_containers(args)
+  (args[:containers] || []).collect.with_index do |container, i|
+    container[:name] = "container-#{i + 1}" unless container.key? :name
+
+    command = _array(container[:command] || [])
+    cpu = container[:cpu] || 1
+    search_domains = _ref_array("search_domains", args)
+    servers = _ref_array("servers", args)
+    label = container[:label] || {}
+    security_options = _array(container[:security_options] || [])
+    entry_point = _array(container[:entry_point] || [])
+    environment = _pair_name_value(container, "environment")
+    extra_hosts = _ecs_extra_hosts(container)
+    host = _name("host", container)
+    image =
+      if container.key? :my_image
+        _join([ _account_id,
+                        ".dkr.ecr.",
+                        _region,
+                        ".#{DOMAIN}/",
+                        container[:my_image],
+                        ":",
+                        container[:my_image_tag] || "latest"
+                      ], "")
       else
-        _ecs_port_mappings({ port_mappings: [ { container_port: 80 } ] })
+        container[:image] || "nginx:latest"
       end
-    volumes_from = _ecs_volumes_from(definition)
-    array << _{
+    links = _array(container[:links] || [])
+    log_config = _ecs_log_configuration(container)
+    memory = container[:memory] || 300
+    memory_reservation = container[:memory_reservation] || 0
+    mount_points = _ecs_mount_points(container)
+    port_mappings = _ecs_port_mappings(container)
+    ulimits = _ecs_ulimits(container)
+    user = container[:user] || ""
+    volumes = _ecs_volumes_from(container)
+    working = container[:working] || ""
+
+    _{
       Command command unless command.empty?
-      Cpu definition[:cpu] || 10
+      Cpu cpu
+      DisableNetworking _bool("networking", container, false)
+      DnsSearchDomains search_domains unless search_domains.empty?
+      DnsServers servers unless servers.empty?
+      DockerLabels label unless label.empty?
+      DockerSecurityOptions security_options unless security_options.empty?
       EntryPoint entry_point unless entry_point.empty?
       Environment environment unless environment.empty?
-      Essential _bool("essential", definition, true)
-      Image definition[:image]   # repository-url/image:tag
+      Essential _bool("essential", container, true)
+      ExtraHosts extra_hosts unless extra_hosts.empty?
+      Hostname host
+      Image image
       Links links unless links.empty?
-      Memory definition[:memory] || 300  # MiB
+      LogConfiguration log_config unless log_config.empty?
+      Memory memory
+      MemoryReservation memory_reservation if 0 < memory_reservation
       MountPoints mount_points unless mount_points.empty?
-      Name _ref_string("name", definition)
+      Name _ref_string("name", container)
       PortMappings port_mappings unless port_mappings.empty?
-      VolumesFrom volumes_from unless volumes_from.empty?
+      Privileged _bool("privileged", container, false)
+      ReadonlyRootFilesystem _bool("read_only", container, false)
+      Ulimits ulimits unless ulimits.empty?
+      User user unless user.empty?
+      VolumesFrom volumes unless volumes.empty?
+      WorkingDirectory working unless working.empty?
+    }
+  end
+end
+
+def _ecs_extra_hosts(args)
+  (args[:extra_hosts] || []).collect do |host|
+    _{
+      HostName host[:name]
+      IpAddress host[:ip]
     }
   end
-  array
+end
+
+def _ecs_log_configuration(args)
+  configuration = args[:log] || []
+  return configuration if configuration.empty?
+
+  driver = _valid_values(configuration[:driver],
+                         %w( json-file syslog journald gelf fluentd awslogs splunk), "awslogs")
+  option = _ecs_to_log_option(configuration)
+  _{
+    LogDriver driver
+    Options option unless option.empty?
+  }
 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]
+  (args[:mount_points] || args[:mounts] || []).collect do |point|
+    _{
+      ContainerPath point[:path]
+      SourceVolume point[:source]
       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?
+  (args[:port_mappings] || args[:ports] || []).collect do |port|
+    host = _ref_string("host", port, 'host port')
+    _{
+      ContainerPort _ref_string("port", port, 'container port')
+      HostPort host unless host.empty?
+      Protocol _valid_values(port[:protocol], %w( tcp udp ), 'tcp')
     }
   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)
+def _ecs_ulimits(args)
+  (args[:ulimits] || []).collect do |ulimit|
+    _{
+      HardLimit ulimit[:hard]
+      Name _name("name", ulimit)
+      SoftLimit ulimit[:hard] || ulimit[:soft]
     }
   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?
+def _ecs_volumes_from(args)
+  (args[:volumes_from] || args[:volumes] || []).collect do |volume|
+    _{
+      SourceContainer _ref_string("source", volume)
+      ReadOnly _bool("read_only", volume, false)
     }
   end
-  array
-end
-
-def _ecs_volumes_host(args)
-  return {} if args.nil? or !args.key? :source_path
-
-  _{
-    SourcePath args[:source_path]
-  }
 end
 
 def _ecs_deployment(args)
-  return "" unless args.key? :max or args.key? :min
+  return "" unless args.key? :deployment
+
+  deployment = args[:deployment]
 
   _{
-    MaximumPercent args[:max]
-    MinimumHealthyPercent args[:min]
+    MaximumPercent deployment[:max] || 200
+    MinimumHealthyPercent deployment[:min] || 50
   }
 end
 
-def _ecs_placement_definition(args)
-  return "" unless args.key? :placement
+def _ecs_placement_definition(args, key = 'placement')
+  placement = args[key.to_sym] || []
+  return placement if placement.empty?
 
-  placement = args[:placement]
   type = _valid_values(placement[:type], %w( distinctInstance memberOf), "distinctInstance")
   expression = placement[:expression] || ""
 
@@ -140,15 +305,15 @@ def _ecs_placement_definition(args)
   }
 end
 
-def _ecs_placement_service(args)
-  return "" unless args.key? :placement
+def _ecs_placement_strategies(args, key = 'placement')
+  placement = args[key.to_sym] || []
+  return placement if placement.empty?
 
-  placement = args[:placement]
   type = _valid_values(placement[:type], %w( random spread binpack ), "random")
   field =
     case type
     when "binpack"
-      _valid_values(args[:field], %w( cpu memory ), "cpu")
+      _valid_values(placement[:field], %w( cpu memory ), "cpu")
     when "spread"
       args[:field] || ""
     else

data/lib/kumogata/template/elasticbeanstalk.rb

@@ -241,7 +241,7 @@ def _elasticbeanstalk_to_option_vpc(args)
   array << {
     name: "aws:ec2:vpc",
     option: "VpcId",
-    value: _ref_name("vpc", args),
+    value: _ref_string("vpc", args, "vpc"),
   }
   array << {
     name: "aws:ec2:vpc",
@@ -282,15 +282,13 @@ def _elasticbeanstalk_to_option_application(args)
 end
 
 def _elasticbeanstalk_to_option_application_environment(args)
-  array = []
-  args.each do |k, v|
-    array << {
+  args.collect do |k, v|
+    {
       name: "aws:elasticbeanstalk:application:environment",
       option: k,
       value: v,
     }
   end
-  array
 end
 
 def _elasticbeanstalk_to_option_logs(args)
@@ -927,15 +925,13 @@ def _elasticbeanstalk_to_option_rds_db_instance(args)
 end
 
 def _elasticbeanstalk_options(options)
-  array = []
-  options.each do |option|
-    array << _{
+  options.collect do |option|
+    _{
       Namespace option[:name]
       OptionName option[:option]
       Value option[:value]
     }
   end
-  array
 end
 
 def _elasticbeanstalk_configuration(configuration)
@@ -959,6 +955,7 @@ def _elasticbeanstalk_tier(tier)
   end
 
   name = _valid_values(tier[:name], %w( WebServer Worker ), "WebServer")
+
   _{
     Name name
     Type (name == "WebServer") ? "Standard" : "SQS/HTTP"

data/lib/kumogata/template/elb.rb

@@ -16,16 +16,12 @@ def _elb_access_logging_policy(args)
 end
 
 def _elb_app_cookie_stickiness_policy(args)
-  array = []
-  apps = args[:app_cookie] || []
-
-  apps.each do |app|
-    array << _{
+  (args[:app_cookie] || []).collect do |app|
+    _{
       CookieName app[:cookie]
       PolicyName app[:policy]
-    }
+     }
   end
-  array
 end
 
 def _elb_connection_draining_policy(args)
@@ -65,24 +61,19 @@ def _elb_health_check(args)
 end
 
 def _elb_cookie_stickiness_policy(args)
-  cookies = args[:cookie_stickiness] || []
-
-  array = []
-  cookies.each do |cookie|
-    array << _{
+  (args[:cookie_stickiness] || []).collect do |cookie|
+    _{
       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|
+  listeners.collect do |listener|
     proto = listener[:protocol] || "http"
     protocol = _valid_values(proto, %w( http https tcp ssl ), "http")
     lb_port =
@@ -108,7 +99,7 @@ def _elb_listeners(args)
     end
     ssl = _ref_string("ssl", listener)
 
-    array << _{
+    _{
       InstancePort instance_port
       InstanceProtocol instance_protocol.upcase
       LoadBalancerPort lb_port
@@ -117,22 +108,17 @@ def _elb_listeners(args)
       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|
+  (args[:policy] || []).collect 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?
@@ -140,5 +126,4 @@ def _elb_policy_types(args)
       PolicyType policy_type
     }
   end
-  array
 end