kumogata-template 0.0.1

data/lib/kumogata/template/emr.rb

@@ -0,0 +1,166 @@
+#
+# Helper - EMR
+#
+require 'kumogata/template/helper'
+
+
+def _emr_applications(args)
+  applications = args[:applications] || []
+
+  array = []
+  applications.each do |application|
+    args = application[:args] || []
+    array << _{
+      #AdditionalInfo
+      Args args unless args.empty?
+      Name application[:name].capitalize
+      Version application[:version] if application.key? :version
+    }
+  end
+  array
+end
+
+def _emr_bootstraps(args)
+  actions = args[:bootstraps] || []
+
+  array = []
+  actions.each do |action|
+    array << _{
+      Name action[:name]
+      ScriptBootstrapAction _{
+        Args action[:script_args] if action.key? :script_args
+        Path action[:script_path]
+      }
+    }
+  end
+  array
+end
+
+def _emr_configurations(args)
+  configurations = args[:configurations] || []
+
+  array = []
+  configurations.each do |configuration|
+    classification = configuration[:classification] || ""
+    properties = configuration[:properties] || []
+    array << _{
+      Classification classification unless classification.empty?
+      ConfigurationProperties properties unless properties.empty?
+      #Configurations
+    }
+  end
+  array
+end
+
+def _emr_ebs(args)
+  ebs = args[:ebs] || []
+  return '' if ebs.empty?
+  ebs_block_devices = ebs.collect{|v| _emr_ebs_block_device(v) }
+
+  _{
+    EbsBlockDeviceConfig ebs_block_devices
+    #EbsOptimized
+  }
+end
+
+def _emr_ebs_block_device(args)
+  volume_spec = _emr_ebs_volume(args)
+  volume_per_instance = args[:per_instance] || ""
+
+  _{
+    VolumeSpecification volume_spec
+    VolumesPerInstance volume_per_instance unless volume_per_instance.empty?
+  }
+end
+
+def _emr_ebs_volume(args)
+  iops = args[:iops] || 300
+  size = _ref_string("size", args, "volume size")
+  type = _valid_values(args[:type], %w( io1 gp2 sc1 st1 ), "gp2")
+
+  _{
+    Iops iops if type == "io1"
+    SizeInGB size
+    VolumeType type
+  }
+end
+
+def _emr_job_flow(args)
+  job = args[:job] || {}
+
+  add_master_security_groups = _ref_array("add_master_security_groups", job, "security group")
+  add_slave_security_groups = _ref_array("add_slave_security_groups", job, "security group")
+  core_instance_group = _emr_instance_group(job[:core])
+  key_name = _ref_string("key_name", job, "key name")
+  subnet = _ref_string("subnet", job, "subnet")
+  emr_master_security_group = _ref_string("emr_master_security_group", job, "security group")
+  emr_slave_security_group = _ref_string("emr_slave_security_group", job, "security group")
+  hadoop_version = _valid_values("hadoop", %w( 1.0.3 2.2.0 2.4.0 ))
+  master = _emr_instance_group(job[:master])
+  placement = job[:placement] || ""
+  service_access_security_group = _ref_string("service_access_security_group", job, "security group")
+  termination = _bool("termination", job, false)
+
+  _{
+    AdditionalMasterSecurityGroups add_master_security_groups unless add_master_security_groups.empty?
+    AdditionalSlaveSecurityGroups add_slave_security_groups unless add_slave_security_groups.empty?
+    CoreInstanceGroup core_instance_group
+    Ec2KeyName key_name unless key_name.empty?
+    Ec2SubnetId subnet unless subnet.empty?
+    EmrManagedMasterSecurityGroup emr_master_security_group unless emr_master_security_group.empty?
+    EmrManagedSlaveSecurityGroup emr_slave_security_group unless emr_slave_security_group.empty?
+    HadoopVersion hadoop_version unless hadoop_version.nil?
+    MasterInstanceGroup master
+    Placement _{
+      AvailabilityZone placement
+    } unless placement.empty?
+    ServiceAccessSecurityGroup service_access_security_group unless service_access_security_group.empty?
+    TerminationProtected termination
+  }
+end
+
+def _emr_instance_group(args)
+  bid = args[:bid] || ""
+  configurations = _emr_configurations(args)
+  instance_count = args[:instance_count] || 1
+  instance_type = _ref_string("instance_type", args, "instance type")
+  instance_type = EMR_DEFAULT_INSTANCE_TYPE  if instance_type.empty?
+  market = _valid_values("market", %w( on_demand, spot), "on_demand")
+  name = _ref_name("name", args)
+
+  _{
+    BidPrice bid unless bid.empty?
+    Configurations configurations unless configurations.empty?
+    InstanceCount instance_count
+    InstanceType instance_type
+    Market market.upcase
+    Name name
+  }
+end
+
+def _emr_hadoop_jar_step_config(args)
+  config_args = args[:args] || []
+  jar = args[:jar]
+  main_class = args[:main_class] || ""
+  step_properties = _emr_step_properties(args)
+
+  _{
+    Args config_args unless config_args.empty?
+    Jar jar
+    MainClass main_class unless main_class.empty?
+    StepProperties step_properties unless step_properties.empty?
+  }
+end
+
+def _emr_step_properties(args)
+  properties = args[:step_properties] || []
+
+  array = []
+  properties.each do |property|
+    _{
+      Key property[:key]
+      Value property[:value]
+    }
+  end
+  array
+end

data/lib/kumogata/template/events.rb

@@ -0,0 +1,25 @@
+#
+# Helper - Events
+#
+require 'kumogata/template/helper'
+
+def _events_pattern(args)
+  pattern = args[:pattern] || ""
+  return "" if pattern.empty?
+
+end
+
+def _events_targets(args)
+  targets = args[:targets] || []
+
+  array = []
+  targets.each do |target|
+    array << _{
+      Arn target[:arn]
+      Id target[:id]
+      Input target[:input] if target.key? :input
+      InputPath target[:path] if target.key? :path
+    }
+  end
+  array
+end

data/lib/kumogata/template/ext/argument_parser.rb

@@ -0,0 +1,8 @@
+class Kumogata::ArgumentParser
+  Kumogata::ArgumentParser::COMMANDS.merge!(
+    init: {
+      :description => 'Generate basic template',
+      :arguments   => [:stack_name],
+    }
+  )
+end

data/lib/kumogata/template/ext/kumogata.rb

@@ -0,0 +1,103 @@
+require 'kumogata'
+require 'kumogata/argument_parser'
+
+class Kumogata::Client
+  def init(stack_name)
+    begin
+      base_template = ''
+      File.open(get_template_path("_template"), "r"){|f|
+        base_template = f.read
+      }
+      raise 'initialize template is empty' if base_template.empty?
+
+      new_template = "#{stack_name}.rb"
+      if File.exists? new_template
+        print "#{new_template} is already exists. Are sure want to overwrite? [y/N]: "
+        answer = STDIN.gets.to_s.chomp
+        return nil if answer.upcase != 'Y'
+      end
+
+      File.open(new_template, "w"){|f|
+        template = base_template.gsub('#{NAME}', stack_name)
+        f.write(template)
+      }
+      Kumogata.logger.info("Saved template to #{stack_name}.rb".green)
+    rescue => e
+      Kumogata.logger.info("Failed to template #{stack_name} - #{e}".red)
+    end
+    nil
+  end
+
+  def define_template_func(scope, path_or_url)
+    functions = ""
+
+    Dir.glob(File.join(get_template_path, "*.rb")).all? do |file|
+      functions << include_func(path_or_url, file)
+      functions << "\n\n"
+    end
+
+    scope.instance_eval(<<-EOS)
+#{functions}
+
+      def _include(file, args = {})
+        path = file.dup
+
+        unless path =~ %r|\\A/| or path =~ %r|\\A\\w+://|
+          path = File.expand_path(File.join(File.dirname(#{path_or_url.inspect}), path))
+        end
+
+        open(path) {|f| instance_eval(f.read) }
+      end
+
+      def _path(path, value = nil, &block)
+        if block
+          value = Dslh::ScopeBlock.nest(binding, 'block')
+        end
+
+        @__hash__[path] = value
+      end
+
+      def _outputs_filter(&block)
+        @__hash__[:_outputs_filter] = block
+      end
+
+      def _post(options = {}, &block)
+        commands = Dslh::ScopeBlock.nest(binding, 'block')
+
+        @__hash__[:_post] = {
+          :options  => options,
+          :commands => commands,
+        }
+      end
+    EOS
+  end
+
+
+  private  ###########################################################
+
+  def include_func(path_or_url, file)
+    <<-EOS
+      def _#{get_funcname(file)}(name, args = {})
+        args[:name] = name unless args.key? :name
+
+        path = "#{file}"
+
+        unless path =~ %r|\\A/| or path =~ %r|\\A\\w+://|
+          path = File.expand_path(File.join(File.dirname(#{path_or_url.inspect}), path))
+        end
+
+        open(path) {|f| instance_eval(f.read) }
+      end
+    EOS
+  end
+
+  def get_funcname(file)
+    File.basename(file, '.rb').gsub('-', '_')
+  end
+
+  def get_template_path(file = nil)
+    template_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..","..", "template"))
+    template_path = File.join(template_path, "#{file}.rb") unless file.nil?
+    template_path
+  end
+end

data/lib/kumogata/template/helper.rb

@@ -0,0 +1,211 @@
+#
+# Helper
+#
+require 'date'
+require 'kumogata/template/const'
+
+def _resource_name(name, append = nil)
+  name = name.to_s
+  name += " #{append}" unless append.nil?
+  name.split.map(&:capitalize).join(' ').gsub(/[-_#,.]/, '').delete(' ')
+end
+
+def _array(args)
+  if args.is_a? String
+    [ args ]
+  elsif args.is_a? Hash
+    args.values
+  else
+    args
+  end
+end
+
+def _bool(name, args, default = false)
+  args.key?(name.to_sym) ? args[name.to_sym].to_s : default.to_s
+end
+
+def _capitalize(name)
+  name.split(' ').map(&:capitalize).join()
+end
+
+def _valid_values(value, values, default = nil)
+  return default if value.nil?
+  values.collect{|v| return v if v =~ /^#{value}$/i }
+  default
+end
+
+def _valid_numbers(value, min = 0, max = 0, default = nil)
+  return default if value.nil?
+  number = value.to_i
+  (min <= number and number <= max) ? number : default
+end
+
+def _ref_string(name, args, ref_name = "")
+  return args[name.to_sym].to_s || "" unless args.key? "ref_#{name}".to_sym
+
+  _{ Ref _resource_name(args["ref_#{name}".to_sym].to_s, ref_name) }
+end
+
+def _ref_array(name, args, ref_name = "")
+  return _array(args[name.to_sym]) || [] unless args.key? "ref_#{name}".to_sym
+
+  array = []
+  if args["ref_#{name}".to_sym].is_a? String
+    array << _ref_string(name, args, ref_name)
+  else
+    args["ref_#{name}".to_sym].collect{|v|
+      array << _{ Ref _resource_name(v, ref_name) }
+    }
+  end
+  array
+end
+
+def _ref_attr_string(name, attr, args, ref_name = "")
+  if args.key? "ref_#{name}".to_sym
+    _{
+      Fn__GetAtt [ _resource_name(args["ref_#{name}".to_sym], ref_name), attr ]
+    }
+  elsif args.key? name.to_sym
+    args[name.to_sym]
+  else
+    ""
+  end
+end
+
+def _ref_name(name, args, ref_name = "")
+  return args["raw_#{name}".to_sym] if args.key? "raw_#{name}".to_sym
+  name = _ref_string(name, args, ref_name)
+  if name.empty?
+    _{ Fn__Join "-", [ _{ Ref "Service" }, _{ Ref "Name" } ] }
+  elsif name.is_a? Hash
+    _{ Fn__Join "-", [ _{ Ref "Service" }, name ] }
+  else
+    name.gsub(' ', '-')
+  end
+end
+
+def _attr_string(name, attr, ref_name = "")
+  _{ Fn__GetAtt [ _resource_name(name, ref_name), attr ] }
+end
+
+def _find_in_map(name, top_level, secondary_level)
+  _{ Fn__FindInMap [ name, top_level, secondary_level ] }
+end
+
+def _tag(args)
+  key = args[:key].to_s || ""
+  value = args[:value] || ""
+  if key =~ /^ref_.*/
+    key.gsub!(/^ref_/, '')
+    value = _{ Ref _resource_name(value) }
+  end
+
+  _{
+    Key _resource_name(key)
+    Value value
+  }
+end
+
+def _tags(args)
+  tags = [
+          _{
+            Key "Name"
+            Value _tag_name(args[:name])
+          },
+          _{
+            Key "Service"
+            Value { Ref _resource_name("service") }
+          },
+          _{
+            Key "Version"
+            Value { Ref _resource_name("version") }
+          },
+         ]
+  args[:tags_append].collect{|k, v| tags << _tag(key: k, value: v) } if args.key? :tags_append
+  tags
+end
+
+def _tag_name(name)
+  _{
+    Fn__Join [ "-", [ _{ Ref _resource_name("service") }, name.to_s.gsub(' ', '-') ] ]
+  }
+end
+
+def _availability_zone(args, use_subnet = true)
+  zone = args.dup
+  zone.delete(:ref_subnet) if use_subnet == false
+  if zone.key? :ref_subnet
+    _ref_attr_string("subnet", "AvailabilityZone", zone, "subnet")
+  elsif  zone.key? :ref_az
+    _ref_string("az", zone)
+  elsif zone.key? :az
+    zone[:az]
+  else
+    ""
+  end
+end
+
+def _availability_zones(args, use_subnet = true)
+  zone = args.dup
+  if use_subnet == false
+    zone.delete(:ref_subnet)
+    zone.delete(:ref_subnets)
+  end
+  if zone.key? :ref_subnet
+    [ _attr_string(args[:ref_subnet], "AvailabilityZone", "subnet") ]
+  elsif zone.key? :ref_subnets
+    zone[:ref_subnets].collect{|v| _ref_attr_string("subnet", "AvailabilityZone", { ref_subnet: v }, "subnet") }
+  elsif args.key? :ref_azs
+    zone[:ref_azs].collect{|v| _ref_string("azs", { ref_azs: v }, "zone") }
+  elsif  args.key? :ref_az
+    [ _ref_string("az", zone, "zone") ]
+  else
+    _{ Fn__GetAZs _{ Ref "AWS::Region" } }
+  end
+end
+
+def _timestamp_utc(year = nil, month = nil, day = nil, hour = 0, min = 0)
+  time =
+    if year.nil?
+      Time.now
+    else
+      Time.local(year, month, day, hour, min)
+    end
+  time.utc.strftime("%Y-%m-%dT%H:%M:00Z")
+end
+
+def _timestamp_utc_from_string(time)
+  time = Time.strptime(time, "%Y-%m-%d %H:%M")
+  _timestamp_utc(time.year, time.month, time.day, time.hour, time.min)
+end
+
+def _maintenance_window(service, start_time)
+  start_time = start_time.utc
+  format = "%a:%H:%M"
+  case service
+  when "elasticache"
+    # 60 min
+    end_time = start_time + (60 * 60)
+  when "rds"
+    # 30 min
+    end_time = start_time + (60 * 30)
+  when "redshift"
+    # 30 min
+    end_time = start_time + (60 * 30)
+  end
+  "#{start_time.strftime(format)}-#{end_time.strftime(format)}"
+end
+
+def _window_time(service, start_time)
+  start_time = start_time.utc
+  format = "%H:%M"
+  case service
+  when "elasticache"
+    # 60 min
+    end_time = start_time + (60 * 60)
+  when "rds"
+    # 30 min
+    end_time = start_time + (60 * 30)
+  end
+  "#{start_time.strftime(format)}-#{end_time.strftime(format)}"
+end