kumogata-template 0.0.35 → 0.0.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ff8b5ee89f699fd747bf383b8dacb8c77f9719a7
-  data.tar.gz: 6f49fa10979f3561aa30ecd31557bee15e6de2fb
+SHA256:
+  metadata.gz: 7c8d9ab5748134f2d4b2f803d7a699707c951515945790d0874e2dbae7d290f0
+  data.tar.gz: 401347892cbc9146e7e7f8c35eb6f0a57026695eeee659c4f038610a4c51d957
 SHA512:
-  metadata.gz: db7151f224695cd9aee542fffed40f72bf28de7bcbc6a473af16f31a9ca3120d95fa7e5fa7210f8af82d494d9e541b3748a5880a8a67a67b79e2c819b8205758
-  data.tar.gz: ba826e18ad1d8b61d1258ae0447aa04255dee4f8ca6be65e9039d6ac5fa3d51ae7830696e4b773c2f235e600b0578152d6895af070c01689e45021c95ebd403e
+  metadata.gz: 7acf0b5c6353373debd184868eb057e6a07ac307307ef4de9e3c4a0115460514ef90a049232f9721be81e2e6d35510d820dd20e2a20dfb84da401854ad119d8a
+  data.tar.gz: 4cf9d0c4105dde1a10aa1dd903c42a0f2b1d8c1caed6e539db15490221f34ab26dcb35a68e2fa482d5ed88d7d45e431b960b1b1dd1c116b1da0a23e419c39694

data/.travis.yml

@@ -2,8 +2,10 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.4.1
-gemfile: n0ts/kumogata-template/Gemfile
+  - 2.5.1
+gemfile: Gemfile
+before_install:
+  - export TZ=Asia/Tokyo
 script:
   - bundle install --path vendor/bundle
   - bundle exec rake

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 ENV['NOKOGIRI_USE_SYSTEM_LIBRARIES'] = 'YES'
 
 # Specify your gem's dependencies in kumogata.gemspec
-gemspec
+gemspec

data/Rakefile

@@ -9,7 +9,7 @@ Rake::TestTask.new do |t|
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   # disable output - warning: assigned but unused variable
-  t.warning = false
+  t.warning = true
   t.verbose = false
   t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
 end

data/kumogata-template.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'aws-sdk', '~> 2.3'
-  spec.add_dependency 'kumogata2-plugin-ruby', '>= 0.1.6'
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'minitest'
+  spec.add_dependency 'kumogata2-plugin-ruby', '~> 0.1'
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 12.3'
+  spec.add_development_dependency 'minitest', '~> 5.11'
 end

data/lib/kumogata/template/alb.rb

@@ -24,6 +24,12 @@ def _alb_to_lb_attribute_idle_timeout(value)
   }
 end
 
+def _alb_to_lb_http2(value = true)
+  {
+    "routing.http2.enabled": value
+  }
+end
+
 def _alb_to_target_group_attribute_delay_timeout(value)
   # wait before changing the state of a deregistering target from draining to unused 0-3600 seconds.
   {
@@ -40,6 +46,18 @@ def _alb_to_target_group_stickiness(value)
   }
 end
 
+def _alb_to_min_health_check(args)
+  {
+    protocol: _valid_values(args[:protocol], %w( http https ), 'http').upcase,
+    path: args[:path] || '/',
+    port: args[:port] || 80,
+    healthy: args[:healthy] || 2,
+    unhealthly: args[:unhealthly] || 2,
+    timeout: args[:timeout] || 2,
+    interval: args[:interval] || 5,
+  }
+end
+
 def _alb_certificates(args)
   certificate = _ref_string("certificate", args)
 
@@ -51,46 +69,39 @@ def _alb_certificates(args)
 end
 
 def _alb_actions(args)
-  defaults = args[:actions] || []
-
-  array = []
-  defaults.each do |default|
+  (args[:actions] || []).collect do |default|
     target = _ref_string("target", default, "target group")
-    array << _{
+    _{
       TargetGroupArn target
       Type "forward"
     }
   end
-  array
 end
 
 def _alb_conditions(args)
-  conditions = args[:conditions] || []
-
-  array = []
-  conditions.each do |condition|
+  (args[:conditions] || []).collect do |condition|
     condition = [ condition ] unless condition.is_a? Array
-    array << _{
+    _{
       Field "path-pattern"
       Values condition
     }
   end
-  array
 end
 
 def _alb_attributes(args)
-  attributes = args[:attributes] || []
-
-  array = []
-  attributes.each do |attribute|
-    attribute.each_pair{|key, value|
-      array << _{
-        Key key
-        Value value
-      }
-    }
-  end
-  array
+  (args[:attributes] || []).collect do |attribute|
+    type = attribute[:type] || ''
+    case type
+    when 'log'
+      attribute = _alb_to_lb_attribute_access_log(attribute)
+    when 'timeout'
+      attribute = _alb_to_lb_attribute_idle_timeout(attribute[:timeout])
+    when 'delay-timeout'
+      attribute = _alb_to_target_group_attribute_delay_timeout(attribute[:timeout])
+    end
+
+    _pair_value({ attribute: attribute }, 'attribute')
+  end.flatten
 end
 
 def _alb_matcher(args)
@@ -103,8 +114,15 @@ def _alb_matcher(args)
 end
 
 def _alb_health_check(args)
+  type = args[:type] || ''
+  case type
+  when 'min'
+    return _alb_to_min_health_check(args)
+  end
+
   protocol = _valid_values(args[:protocol] || "", %w( http https ), "http")
-  # Return to native hash
+
+  # return to native hash
   {
     interval: args[:interval] || 30,
     path: args[:path] || "/",
@@ -117,24 +135,20 @@ def _alb_health_check(args)
 end
 
 def _alb_targets(args)
-  targets = args[:targets] || []
-  ref_targets = args[:ref_targets] || []
-
-  array = []
-  targets.each do |target|
+  targets = (args[:targets] || []).collect do |target|
     id = _ref_string("instance", target, "instance")
-    array << _{
+    _{
       Id id
       Port target[:port] if target.key? :port
     }
   end
 
-  ref_targets.each do |target|
-    array << _{
+  targets += (args[:ref_targets] || []).collect do |target|
+    _{
       Id _ref_string("instance", { ref_instance: target }, "instance")
       Port 80
     }
   end
 
-  array
+  targets
 end

data/lib/kumogata/template/api-gateway.rb

@@ -0,0 +1,262 @@
+#
+# Helper - Api Gateway
+#
+require 'kumogata/template/helper'
+
+def _api_gateway_to_parameter(args)
+  type = _valid_values(args[:type], %w( integration method ), "method")
+  location = _valid_values(args[:location], %w( querystring path header ), "path")
+  operation = args[:operation] || "request"
+  "#{type}.#{operation}.#{location}.#{args[:name]}"
+end
+
+def _api_gateway_to_parameter_headers(kind)
+  headers =
+    case kind
+    when "aws"
+      [
+       { name: "X-AWS-Request-Id", value: "context.requestId" },
+       { name: "X-AWS-API-Id", value: "context.apiId" },
+      ]
+    when "cognito"
+      [
+       { name: "X-AWS-Cognito-Identity-Id", value: "context.identity.cognitoIdentityId" },
+       { name: "X-AWS-Cognito-Identity-Pool-Id", value: "context.identity.cognitoIdentityPoolId" },
+       { name: "X-AWS-Cognito-Authentication-Type", value: "context.identity.cognitoAuthenticationType" },
+       { name: "X-AWS-Cognito-Authentication-Provider", value: "context.identity.cognitoAuthenticationProvider" },
+      ]
+    else
+      []
+    end
+  return headers if headers.empty?
+
+  headers.collect{|v| v.merge!({ location: "header" }) }
+end
+
+def _api_gateway_to_parameter_response_headers(args = {})
+  headers = {}
+  key = _api_gateway_to_parameter({ operation: "response",
+                                    location: "header",
+                                    name: "Access-Control-Allow-Methods" })
+  headers[key] = "'DELETE,GET,HEAD,OPTIONS,PATCH,POST,PUT'"
+
+  key = _api_gateway_to_parameter({ operation: "response",
+                                    location: "header",
+                                    name: "Access-Control-Allow-Headers" })
+  allow_headers = %w( Content-Type Authorization X-Amz-Date X-Api-Key X-Amz-Security-Token)
+  allow_headers += args[:allow_headers] if args.key? :allow_headers
+  headers[key] = sprintf("'%s'", allow_headers.join(','))
+
+  key = _api_gateway_to_parameter({ operation: "response",
+                                    location: "header",
+                                    name: "Access-Control-Allow-Origin" })
+  headers[key] = "'*'"
+
+  headers
+end
+
+def _api_gateway_stage_keys(args)
+  (args[:stage_keys] || []).collect do |key|
+    rest = _ref_string("rest", key, "reset api")
+    stage = _ref_string("stage", key)
+    _{
+      RestApiId rest
+      StageName stage
+    }
+  end
+end
+
+def _api_gateway_integration(args)
+  args_proxy = _bool("proxy", args, false)
+  args_parameters = args[:parameters] || []
+
+  integration = args[:integration] || {}
+  return integration if integration.empty?
+
+  cache_keys = integration[:cache_keys] || []
+  cache_keys << _api_gateway_to_parameter({ type: "method", location: "path", name: "proxy" }) if args_proxy
+  cache_ns = integration[:cache_ns] || ""
+  http =
+    if args_proxy
+      "any"
+    else
+      _valid_values(integration[:http], %w( delete get head options patch post put any ), "any")
+    end
+  responses =
+    if integration.key? :responses
+      integration[:responses].collect{|v| _api_gateway_integration_response(v) }
+    else
+      []
+    end
+  responses << _api_gateway_integration_response({ template: { "application/json": "null" } }) if args_proxy
+  pass =
+    if args_proxy
+      "when_no_match"
+    else
+      _valid_values(integration[:pass], %w( when_no_match when_no_templates never ), "")
+    end
+  role = _ref_attr_string("role", "Arn", integration)
+  parameters = {}
+  args_parameters.collect do |v|
+    k = _api_gateway_to_parameter({ type: "integration", location: v[:location], name: v[:name] })
+    parameters[k] = _api_gateway_to_parameter(v)
+  end
+  (integration[:parameters] || []).collect do |v|
+    k = _api_gateway_to_parameter({ type: "integration", location: v[:location], name: v[:name] })
+    parameters[k] = v[:value]
+  end
+  # RequestTemplates
+  # - Key: The content type value
+  # - Value: the template http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
+  templates = integration[:templates] || {}
+  type =
+    if args_proxy
+      "http_proxy"
+    else
+      _valid_values(integration[:type], %w( mock http http_proxy aws aws_proxy ), "http")
+    end
+
+  uri =
+    case type
+    when /http/
+      _ref_string("uri", integration)
+    when /aws/
+      _iam_arn("api-gateway", integration)
+    else
+      ""
+    end
+  uri = _join([ uri, "{proxy}" ], "/") if args_proxy
+
+  _{
+    CacheKeyParameters cache_keys unless cache_keys.empty?
+    CacheNamespace cache_ns unless cache_ns.empty?
+    Credentials role unless role.empty?
+    IntegrationHttpMethod http.upcase if type != "mock"
+    IntegrationResponses responses unless responses.empty?
+    PassthroughBehavior pass.upcase unless pass.empty?
+    RequestParameters parameters unless parameters.empty?
+    RequestTemplates templates unless templates.empty?
+    Type type.upcase
+    Uri uri unless uri.empty?
+  }
+end
+
+def _api_gateway_integration_response(args)
+  parameter = args[:parameter] || {}
+  template = args[:template] || {}
+  selection = args[:selection] || ""
+  status = args[:status] || 200
+
+  _{
+    ResponseParameters parameter unless parameter.empty?
+    ResponseTemplates template unless template.empty?
+    SelectionPattern selection unless selection.empty?
+    StatusCode status
+  }
+end
+
+def _api_gateway_responses(args)
+  (args[:responses] || []).collect do |response|
+    models = response[:models] || []
+    parameters = response[:parameters] || []
+    status = response[:status] || 200
+
+    _{
+      ResponseModels models unless models.empty?
+      ResponseParameters parameters unless parameters.empty?
+      StatusCode status
+    }
+  end
+end
+
+def _api_gateway_stage_description(args)
+  description = args[:stage_description] || {}
+  return description if description.empty?
+
+  cache = description[:cache] || {}
+  certificate = _ref_string_default("certificate", description, "certificate")
+  data_trace = _bool("data_trace", description, false)
+  description_desc = description[:description] || ""
+  logging = _valid_values(description[:logging], %w( off error info ), "off")
+  method = _api_gateway_method_settings(description)
+  metrics = _bool("metrics", description, false)
+  stage = _name("stage", description)
+  throtting = description[:throtting] || {}
+  variables = description[:variables] || {}
+
+  _{
+    CacheClusterEnabled true if cache.key? :cluster
+    CacheClusterSize cache[:size] unless cache.empty?
+    CacheDataEncrypted true if cache.key? :encrypted
+    CacheTtlInSeconds cache[:ttl] unless cache.empty?
+    CachingEnabled cache.empty? ? false : true
+    ClientCertificateId certificate unless certificate.empty?
+    DataTraceEnabled data_trace
+    Description description unless description_desc.empty?
+    LoggingLevel logging.upcase
+    MethodSettings method unless method.empty?
+    MetricsEnabled metrics
+    StageName stage
+    ThrottlingBurstLimit throtting[:burst] unless throtting.empty?
+    ThrottlingRateLimit throtting[:rate] unless throtting.empty?
+    Variables variables unless variables.empty?
+  }
+end
+
+def _api_gateway_method_settings(args)
+  (args[:settings] || []).collect do |setting|
+    cache = setting[:cache] || {}
+    data_trace = _bool("data_trace", setting, false)
+    http = setting[:http] || "*"
+    logging = _valid_values(setting[:logging], %w( off error info ), "info")
+    metrics = _bool("metrics", setting, false)
+    resource = setting[:resource] || "/*"
+    throtting = setting[:throtting] || {}
+
+    _{
+      CacheDataEncrypted cache[:encrypted] unless cache.empty?
+      CacheTtlInSeconds cache[:ttl] unless cache.empty?
+      CachingEnabled cache.empty? ? false : true
+      DataTraceEnabled data_trace
+      HttpMethod http
+      LoggingLevel logging.upcase
+      MetricsEnabled metrics
+      ResourcePath resource
+      ThrottlingBurstLimit throtting[:burst] unless throtting.empty?
+      ThrottlingRateLimit throtting[:rate] unless throtting.empty?
+    }
+  end
+end
+
+def _api_gateway_stages(args)
+  (args[:stages] || []).collect do |stage|
+    _{
+      ApiId _ref_string("rest", stage, "rest api")
+      Stage _ref_string("stage", stage, "stage")
+    }
+  end
+end
+
+def _api_gateway_quota(args)
+  quota = args[:quota] || {}
+  return quota if quota.empty?
+
+  offset = quota[:offset] || ""
+  period = _valid_values(quota[:period], %w( day week month ), "month")
+
+  _{
+    Limit quota[:limit]
+    Offset offset unless offset.empty?
+    Period period.upcase
+  }
+end
+
+def _api_gateway_throttle(args)
+  throttle = args[:throttle] || {}
+  return throttle if throttle.empty?
+
+  _{
+    BurstLimit throttle[:bust]
+    RateLimit throttle[:rate]
+  }
+end

data/lib/kumogata/template/autoscaling.rb

@@ -107,53 +107,26 @@ def _autoscaling_step(args)
   }
 end
 
-def _autoscaling_tags(args)
-  tags = [
-          _{
-            Key "Name"
-            Value _tag_name(args)
-            PropagateAtLaunch _bool("tag_name_launch", args, true)
-          },
-          _{
-            Key "Service"
-            Value { Ref _resource_name("service") }
-            PropagateAtLaunch _bool("tag_service_launch", args, true)
-          },
-          _{
-            Key "Version"
-            Value { Ref _resource_name("version") }
-            PropagateAtLaunch _bool("tag_version_launch", args, true)
-          },
-         ]
-  if args.key? :tags_append
-    args[:tags_append].each do|key, value|
-      tag = _tag({ key: key, value: value })
-      tag["PropagateAtLaunch"] = _bool("tag_#{key}_launch", args, true)
-      tags << tag
-    end
+def _autoscaling_tags(args, tag_name = "tag_name")
+  _tags(args, tag_name).collect do |tag|
+    tag["PropagateAtLaunch"] = _bool("#{tag["Key"].downcase}_launch", args, true).to_s
+    tag
   end
-  tags
 end
 
 def _autoscaling_terminations(args)
-  terminations = args[:terminations]
-  return [] if terminations.nil?
-
-  array = []
-  terminations.each do |termination|
-    array <<
-      case termination.downcase
-      when "old instance"
-        "OldestInstance"
-      when "new instance"
-        "NewestInstance"
-      when "old launch"
-        "OldestLaunchConfiguration"
-      when "close"
-        "ClosestToNextInstanceHour"
-      else
-        "Default"
-      end
+  (args[:terminations] || []).collect do |termination|
+    case termination.downcase
+    when "old instance"
+      "OldestInstance"
+    when "new instance"
+      "NewestInstance"
+    when "old launch"
+      "OldestLaunchConfiguration"
+    when "close"
+      "ClosestToNextInstanceHour"
+    else
+      "Default"
+    end
   end
-  array
 end

data/lib/kumogata/template/certificate.rb

@@ -4,15 +4,18 @@
 require 'kumogata/template/helper'
 
 def _certificate_validations(args)
-  validation = args[:validation] || []
-  validation << { domain: args[:domain], validation: args[:domain] } if validation.empty?
+  validations = args[:validation] || []
+  return [ _{
+             DomainName _ref_string("domain", args, "domain")
+             ValidationDomain _ref_string("domain", args, "domain")
+           } ] if validations.empty?
 
-  result = []
-  validation.each do |val|
-    result << _{
-      DomainName val[:domain]
-      ValidationDomain val[:validation]
+  validations.collect do |validation|
+    domain = _ref_string("domain", validation, "domain")
+    validation = _ref_string("validation", validation, "domain")
+    _{
+      DomainName domain
+      ValidationDomain validation || domain
     }
   end
-  result
 end