kakine 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3f0de2336304ed3476ccfc1b63e2bdc01a9c1cd
-  data.tar.gz: c1b97adbc29b5a659b1fb38b79f04dcb596a1f53
+  metadata.gz: 70641f4e229c0b370d35779df007a7df6da8652f
+  data.tar.gz: 2dde1b80581774ea0c74f8848e4f703e25faf22f
 SHA512:
-  metadata.gz: c402eeb05b5d24368f1b66694965fa8fac9116a8354c11a69a33c5bc64695f9d107ed63072f523a1da22d9520bf86eed35bedff78e1811da249ae91b5ccd1c11
-  data.tar.gz: a2c41d220786673210a397f27d049f7d52c6ec5ae5aa623361eb08fd62d8634d7d70350d3a303f931ff2799657d9c1295dc28df9432d065ec9ed61ed9ae2fbde
+  metadata.gz: 4cead3fba0343c55d0af964843358cdcaaee3e6b0249a5e18195b8fc84cc266cab4930faa0c6cac8012ed111c32a36ac567fa3bc00a32f8fced787a74d6d92d1
+  data.tar.gz: 08660d1645a78545d7bf22aff0f0dd074de1d0b358045428a559a1b604350e2f165812eb8351c17d9a63742c0e33bd009e87fc251a8d0f217e3c47c7e32fc85a

data/lib/kakine.rb

@@ -1,11 +1,11 @@
 require "kakine/version"
 require 'kakine/cli'
-require 'kakine/cli/operation'
+require 'kakine/operation'
 require 'kakine/adapter'
 require 'kakine/resource'
-require 'kakine/hash_sort'
 require 'kakine/security_group'
-require 'kakine/diff_parser'
+require 'kakine/security_rule'
+require 'kakine/validate'
 
 module Kakine
 end

data/lib/kakine/adapter.rb

@@ -1,2 +1,22 @@
 require 'kakine/adapter/real'
 require 'kakine/adapter/mock'
+
+module Kakine
+  class Adapter
+    def self.set_option(dryrun)
+      @@dryrun = dryrun
+    end
+
+    def self.get_instance
+      @@adapter ||= if @@dryrun
+        Kakine::Adapter::Mock.new
+      else
+        Kakine::Adapter::Real.new
+      end
+    end
+
+    private
+    def initialize
+    end
+  end
+end

data/lib/kakine/adapter/mock.rb

@@ -1,18 +1,16 @@
 module Kakine
   class Adapter
     class Mock
-      def create_rule(security_group_id, direction, attributes)
-        attributes.delete("direction")
-        if attributes["port"]
-          attributes["port_range_max"] = attributes["port_range_min"] = attributes.delete("port")
+      def create_rule(security_group_id, direction, security_rule)
+        attributes = {}
+        %w(protocol port_range_max port_range_min remote_ip ethertype).each do |k|
+          attributes[k] = eval("security_rule.#{k}")
         end
         if attributes["remote_ip"]
           attributes["remote_ip_prefix"] = attributes.delete("remote_ip")
         end
 
-        data = {}
-        attributes.each{|k,v| data[k.to_sym] = v}
-        puts "Create Rule: #{security_group_id} - #{direction}: #{attributes}"
+        puts "Create Rule: #{security_group_id} - #{security_rule.direction}: #{attributes}"
       end
 
       def delete_rule(security_group_rule_id)

data/lib/kakine/adapter/real.rb

@@ -1,10 +1,11 @@
+require 'json'
 module Kakine
   class Adapter
     class Real
-      def create_rule(security_group_id, direction, attributes)
-        attributes.delete("direction")
-        if attributes["port"]
-          attributes["port_range_max"] = attributes["port_range_min"] = attributes.delete("port")
+      def create_rule(security_group_id, direction, security_rule)
+        attributes = {}
+        %w(protocol port_range_max port_range_min remote_ip ethertype).each do |k|
+          attributes[k] = eval("security_rule.#{k}")
         end
         if attributes["remote_ip"]
           attributes["remote_ip_prefix"] = attributes.delete("remote_ip")
@@ -12,7 +13,13 @@ module Kakine
 
         data = {}
         attributes.each{|k,v| data[k.to_sym] = v}
-        Fog::Network[:openstack].create_security_group_rule(security_group_id, direction, data)
+        begin
+          Fog::Network[:openstack].create_security_group_rule(security_group_id, direction, data)
+        rescue Excon::Errors::Conflict => e
+          JSON.parse(e.response[:body]).each { |e,m| puts "#{e}:#{m["message"]}" }
+        rescue Excon::Errors::BadRequest => e
+          JSON.parse(e.response[:body]).each { |e,m| puts "#{e}:#{m["message"]}" }
+        end
       end
 
       def delete_rule(security_group_rule_id)
@@ -22,12 +29,24 @@ module Kakine
       def create_security_group(attributes)
         data = {}
         attributes.each{|k,v| data[k.to_sym] = v}
-        response = Fog::Network[:openstack].create_security_group(data)
-        response.data[:body]["security_group"]["id"]
+        begin
+          response = Fog::Network[:openstack].create_security_group(data)
+          response.data[:body]["security_group"]["id"]
+        rescue Excon::Errors::Conflict => e
+          JSON.parse(e.response[:body]).each { |e,m| puts "#{e}:#{m["message"]}" }
+        rescue Excon::Errors::BadRequest => e
+          JSON.parse(e.response[:body]).each { |e,m| puts "#{e}:#{m["message"]}" }
+        end
       end
 
       def delete_security_group(security_group_id)
-        Fog::Network[:openstack].delete_security_group(security_group_id)
+        begin
+          Fog::Network[:openstack].delete_security_group(security_group_id)
+        rescue Excon::Errors::Conflict => e
+          JSON.parse(e.response[:body]).each { |e,m| puts "#{e}:#{m["message"]}" }
+        rescue Excon::Errors::BadRequest => e
+          JSON.parse(e.response[:body]).each { |e,m| puts "#{e}:#{m["message"]}" }
+        end
       end
     end
   end

data/lib/kakine/cli.rb

@@ -2,7 +2,6 @@ require 'thor'
 require 'fog'
 require 'yaml'
 require 'hashdiff'
-
 module Kakine
   class CLI < Thor
 
@@ -17,62 +16,23 @@ module Kakine
     option :filename, type: :string, aliases: "-f"
     desc 'apply', "apply local configuration into OpenStack"
     def apply
-      adapter = if options[:dryrun]
-        Kakine::Adapter::Mock.new
-      else
-        Kakine::Adapter::Real.new
-      end
-
-      operation = Kakine::CLI::Operation.new
-      operation.set_adapter(adapter)
-
       filename = options[:filename] ? options[:filename] : "#{options[:tenant]}.yaml"
-
-      security_groups = []
-      delay_create = []
-
-      diffs = HashDiff.diff(
-        Kakine::Resource.security_groups_hash(options[:tenant]),
-        Kakine::Resource.yaml(filename)
-      )
-
-      diffs.each do |diff|
-        security_groups <<  Kakine::SecurityGroup.new(options[:tenant], diff)
-      end
-
-      security_groups.each do |sg|
-        if sg.update_rule? # foo[2]
-          case
-          when sg.add?
-            operation.create_security_rule(sg)
-          when sg.delete?
-            operation.delete_security_rule(sg)
-          when sg.update_attr?
-            pre_sg = sg.get_prev_instance
-            operation.delete_security_rule(pre_sg)
-            delay_create << sg # avoid duplication entry
-          else
-            raise
-          end
-        else # foo
-          case
-          when sg.add?
-            security_group_id = operation.create_security_group(sg)
-            operation.create_security_rule(sg, security_group_id)
-          when sg.delete?
-            operation.delete_security_group(sg)
-          when sg.update_attr?
-            operation.delete_security_group(sg)
-            security_group_id = operation.create_security_group(sg)
-            operation.create_security_rule(sg, security_group_id)
-          else
-            raise
-          end
+      Kakine::Adapter.set_option(options[:dryrun])
+
+      current_security_groups  = Kakine::Resource.get_current(options[:tenant])
+      new_security_groups = Kakine::Resource.load_security_group_by_yaml(filename, options[:tenant])
+
+      return unless new_security_groups
+      new_security_groups.each do |new_sg|
+        registered_sg  = current_security_groups.find { |cur_sg| cur_sg.name == new_sg.name }
+        if registered_sg
+          new_sg.convergence!(registered_sg) if new_sg != registered_sg
+        else
+          new_sg.register!
         end
       end
-      # update rule attributes delay create
-      delay_create.each do |sg|
-        operation.create_security_rule(sg)
+      current_security_groups.each do |current_sg|
+        current_sg.unregister! if new_security_groups.none? { |new_sg| current_sg.name == new_sg.name }
       end
     end
   end

data/lib/kakine/operation.rb

@@ -0,0 +1,38 @@
+module Kakine
+  class Operation
+    class << self
+      def adapter
+        @@adapter ||= Kakine::Adapter.get_instance
+      end
+
+      def create_security_group(sg)
+        attributes = {name: sg.name, description: sg.description, tenant_id: sg.tenant_id}
+        security_group_id = adapter.create_security_group(attributes)
+
+        #delete default rule
+        sg.get_default_rule_instance.rules.each { |rule| rule.unregister! } unless adapter.instance_of?(Kakine::Adapter::Mock)
+        security_group_id
+      end
+
+      def delete_security_group(sg)
+        security_group = Kakine::Resource.security_group(sg.tenant_name, sg.name)
+        adapter.delete_security_group(security_group.id)
+      end
+
+      def create_security_rule(tenant_name, sg_name, rule)
+        security_group_id = if adapter.instance_of?(Kakine::Adapter::Mock)
+          "[Mock] #{sg_name} ID"
+        else
+          Kakine::Resource.security_group(tenant_name, sg_name).id
+        end
+        adapter.create_rule(security_group_id, rule.direction, rule)
+      end
+
+      def delete_security_rule(tenant_name, sg_name, rule)
+        security_group = Kakine::Resource.security_group(tenant_name, sg_name)
+        security_group_rule = Kakine::Resource.security_group_rule(security_group, rule)
+        adapter.delete_rule(security_group_rule.id)
+      end
+    end
+  end
+end

data/lib/kakine/resource.rb

@@ -1,9 +1,20 @@
-require 'kakine/hash_sort'
 module Kakine
   class Resource
     class << self
+      def load_security_group_by_yaml(filename, tenant_name)
+        load_yaml = yaml(filename)
+        return false unless Kakine::Validate.validate_file_input(load_yaml)
+        load_yaml.map { |sg| Kakine::SecurityGroup.new(tenant_name, sg) }
+      end
+
+      def get_current(tenant_name)
+        Kakine::Resource.security_groups_hash(tenant_name).map do |sg|
+          Kakine::SecurityGroup.new(tenant_name, sg)
+        end
+      end
+
       def yaml(filename)
-        YAML.load_file(filename).to_hash.sg_rules_sort
+        YAML.load_file(filename).to_hash
       end
 
       def tenant(tenant_name)
@@ -16,22 +27,20 @@ module Kakine
 
       def security_group_rule(security_group, attributes)
         security_group.security_group_rules.detect do |sg|
-          if attributes["port"]
-            attributes["port_range_max"] = attributes["port_range_min"] = attributes["port"]
-          end
 
-          sg.direction == attributes["direction"] &&
-          sg.protocol == attributes["protocol"] &&
-          sg.port_range_max == attributes["port_range_max"] &&
-          sg.port_range_min == attributes["port_range_min"] &&
+          sg.direction == attributes.direction &&
+          sg.protocol == attributes.protocol &&
+          sg.port_range_max == attributes.port_range_max &&
+          sg.port_range_min == attributes.port_range_min &&
+          sg.ethertype == attributes.ethertype &&
           (
             (
-              sg.remote_ip_prefix == attributes["remote_ip"] &&
-              sg.ethertype == attributes["ethertype"]
+              attributes.remote_group_id.nil? &&
+              sg.remote_ip_prefix == attributes.remote_ip
             ) ||
             (
-              sg.remote_group_id == attributes["remote_group_id"] &&
-              !attributes["remote_group_id"].nil?
+              attributes.remote_ip.nil? &&
+              sg.remote_group_id == attributes.remote_group_id
             )
           )
         end
@@ -48,22 +57,24 @@ module Kakine
           sg_hash[sg.name]["rules"]       = format_security_group(sg)
           sg_hash[sg.name]["description"] = sg.description
         end
-        sg_hash.sg_rules_sort
+        sg_hash
       end
 
       def format_security_group(security_group)
-        rules = []
-
-        security_group.security_group_rules.each do |rule|
+        security_group.security_group_rules.map do |rule|
           rule_hash = {}
           rule_hash["direction"] = rule.direction
-          rule_hash["protocol"] = rule.protocol
+          rule_hash["protocol"]  = rule.protocol
+          rule_hash["ethertype"] = rule.ethertype
 
-          if rule.port_range_max == rule.port_range_min
+          if rule.protocol == "icmp"
+            rule_hash["type"] = rule.port_range_min
+            rule_hash["code"] = rule.port_range_max
+          elsif rule.port_range_max == rule.port_range_min
             rule_hash["port"] = rule.port_range_max
           else
-            rule_hash["port_range_max"] = rule.port_range_max
             rule_hash["port_range_min"] = rule.port_range_min
+            rule_hash["port_range_max"] = rule.port_range_max
           end
 
           if rule.remote_group_id
@@ -71,11 +82,9 @@ module Kakine
             rule_hash["remote_group"] = response.data[:body]["security_group"]["name"]
           else
             rule_hash["remote_ip"] = rule.remote_ip_prefix
-            rule_hash["ethertype"] = rule.ethertype
           end
-          rules << rule_hash
+          rule_hash
         end
-        rules
       end
     end
   end

data/lib/kakine/security_group.rb

@@ -1,76 +1,80 @@
+require 'json'
 module Kakine
   class SecurityGroup
-    attr_reader :target_object_name, :name, :transaction_type, :tenant_id, :tenant_name, :description, :rules, :prev_rules
+    attr_reader :name, :tenant_id, :tenant_name, :description, :rules
 
-    def initialize(tenant_name, diff)
-      unset_security_rules
-      Kakine::DiffParser.parse_parameters(tenant_name, diff).each do|k,v|
-        instance_variable_set(eval(":@#{k.to_s}"), v)
-      end
-      set_remote_security_group_id
+    def initialize(tenant_name, parameter)
+      @name = parameter[0]
+      @tenant_name = tenant_name
+      @tenant_id = Kakine::Resource.tenant(tenant_name).id
+      @description = parameter[1]["description"] || ""
+      @rules = parameter[1]["rules"].map do |rule|
+        SecurityRule.new(rule, @tenant_name, @name)
+      end unless parameter[1]["rules"].nil?
+      @rules ||= []
     end
 
     def initialize_copy(obj)
       @rules = Marshal.load(Marshal.dump(obj.rules))
-      @prev_rules = Marshal.load(Marshal.dump(obj.prev_rules))
-      unset_security_rules
-    end
-
-    def has_rules?
-      @rules.detect {|v| !v.nil? && v.size > 0}
     end
 
-    def add?
-      @transaction_type == "+"
+    def ==(target_sg)
+      instance_variables.reject{ |k| k == :@rules }.each do |val|
+        return false unless self.instance_variable_get(val) == target_sg.instance_variable_get(val)
+      end
+      @rules.each do |rule|
+        return false unless target_sg.find_by_rule(rule)
+      end
+      target_sg.rules.each do |rule|
+        return false unless find_by_rule(rule)
+      end
+      true
     end
 
-    def delete?
-      @transaction_type == "-"
+    def !=(target_sg)
+      !(self == target_sg)
     end
 
-    def update_attr?
-      @transaction_type == "~"
+    def find_by_rule(target_rule)
+      @rules.find { |rule| rule == target_rule }
     end
 
-    def update_rule?
-      !@target_object_name.split(/[\[]/, 2)[1].nil?
+    def register!
+      Kakine::Operation.create_security_group(self)
+      @rules.each { |rule| rule.register! } if has_rules?
     end
 
-    def get_prev_instance
-      prev_sg = self.clone
-      prev_sg.add_security_rules(@prev_rules)
-      prev_sg
+    def unregister!
+      Kakine::Operation.delete_security_group(self)
     end
 
-    def set_default_rules
-      unset_security_rules
-      ["IPv4", "IPv6"].each do |ip|
-          add_security_rules({"direction"=>"egress", "protocol"=>nil, "port"=>nil, "remote_ip"=>nil, "ethertype"=>ip})
+    def convergence!(target_sg)
+      if @description != target_sg.description
+        target_sg.unregister!
+        register!
+      else
+        target_sg.rules.each do |rule|
+          rule.unregister! unless find_by_rule(rule)
+        end
+        @rules.each do |rule|
+          rule.register! unless target_sg.find_by_rule(rule)
+        end
       end
     end
 
-    def add_security_rules(rule)
-      case
-        when rule.instance_of?(Array)
-          @rules = rule
-        when rule.instance_of?(Hash)
-          @rules << rule
-      end
+    def has_rules?
+      @rules.detect {|v| !v.nil?}
     end
 
-    private
-
-    def unset_security_rules
-      @rules = []
+    def get_default_rule_instance
+      default_sg = self.clone
+      default_sg.set_default_rule
+      default_sg
     end
 
-    def set_remote_security_group_id
-      @rules.each do |rule|
-        unless rule['remote_group'].nil?
-          remote_security_group = Kakine::Resource.security_group(@tenant_name, rule.delete("remote_group"))
-          rule["remote_group_id"] = remote_security_group.id
-        end
-      end if has_rules?
+    def set_default_rule
+      @rules = %w(IPv4 IPv6).map { |v| {"direction"=>"egress", "protocol" => nil, "port"=>nil, "remote_ip"=>nil, "ethertype"=>v } }.
+        map{ |rule| SecurityRule.new(rule, @tenant_name, @name) }
     end
   end
 end

data/lib/kakine/security_rule.rb

@@ -0,0 +1,58 @@
+module Kakine
+  class SecurityRule
+    attr_reader :direction, :protocol, :port_range_max, :port_range_min, :remote_ip, :remote_group, :remote_group_id, :ethertype
+
+    def initialize(rule, tenant_name, sg_name)
+      @tenant_name = tenant_name
+      @sg_name = sg_name
+
+      rule.each do|k,v|
+        instance_variable_set(eval(":@#{k.to_s}"), v) unless k.include?("port")
+      end
+
+      @port_range_min, @port_range_max = *convert_port_format(rule)
+      set_remote_security_group_id
+
+    end
+
+    def register!
+      Kakine::Operation.create_security_rule(@tenant_name, @sg_name, self)
+    end
+
+    def unregister!
+      Kakine::Operation.delete_security_rule(@tenant_name, @sg_name, self)
+    end
+
+    def ==(target_sg)
+      instance_variables.each do |val|
+        unless self.instance_variable_get(val) == target_sg.instance_variable_get(val)
+          return false
+        end
+      end
+      true
+    end
+
+    private
+
+    def convert_port_format(rule)
+      case
+      when rule.has_key?('port')
+        [rule['port'] ,rule['port']]
+      when rule.has_key?('type'), rule.has_key?('code')
+        [rule['type'] ,rule['code']]
+      when rule.has_key?('port_range_max'), rule.has_key?('port_range_min')
+        [rule['port_range_min'] ,rule['port_range_max']]
+      else
+        raise "no match port format"
+      end
+    end
+
+    def set_remote_security_group_id
+      unless @remote_group.nil?
+        remote_security_group = Kakine::Resource.security_group(@tenant_name, @remote_group)
+        raise "not exists #{@remote_group}" unless remote_security_group
+        @remote_group_id = remote_security_group.id
+      end
+    end
+  end
+end

data/lib/kakine/validate.rb

@@ -0,0 +1,42 @@
+module Kakine
+  class Validate
+    class << self
+      def validate_file_input(load_sg)
+        err = []
+        load_sg.each do |sg|
+          err << validate_attributes(sg)
+          err << validate_rules(sg)
+        end
+        return true unless err.detect {|e| !e.nil? }
+        err.map { |m| puts m unless m.nil? }
+        false
+      end
+
+      def validate_attributes(sg)
+        case
+        when sg[1].nil?
+          "[error] #{sg[0]}:rules and description is required"
+        when !sg[1].key?("rules")
+          "[error] #{sg[0]}:rules is required"
+        when !sg[1].key?("description")
+          "[error] #{sg[0]}:description is required"
+        end
+      end
+
+      def validate_rules(sg)
+        sg[1]["rules"].each do |rule|
+          if !rule.key?("port") &&
+            (!rule.key?("port_range_max") || !rule.key?("port_range_min")) &&
+            (!rule.key?("type") || !rule.key?("code"))
+            return "[error] #{sg[0]}:rules port(icmp code) is required"
+          elsif !rule.key?("remote_ip") && !rule.key?("remote_group")
+            return "[error] #{sg[0]}:rules remote_ip or remote_group required"
+          elsif col = %w(direction protocol ethertype).find { |k| !rule.key?(k) }
+            return "[error] #{sg[0]}:rules #{col} is required"
+          end
+        end unless sg[1]["rules"].nil?
+        nil
+      end
+    end
+  end
+end

data/lib/kakine/version.rb

@@ -1,3 +1,3 @@
 module Kakine
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kakine
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - SHIBATA Hiroshi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2015-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -131,11 +131,11 @@ files:
 - lib/kakine/adapter/mock.rb
 - lib/kakine/adapter/real.rb
 - lib/kakine/cli.rb
-- lib/kakine/cli/operation.rb
-- lib/kakine/diff_parser.rb
-- lib/kakine/hash_sort.rb
+- lib/kakine/operation.rb
 - lib/kakine/resource.rb
 - lib/kakine/security_group.rb
+- lib/kakine/security_rule.rb
+- lib/kakine/validate.rb
 - lib/kakine/version.rb
 homepage: https://github.com/hsbt/kakine
 licenses:

data/lib/kakine/cli/operation.rb

@@ -1,44 +0,0 @@
-module Kakine
-  class CLI < Thor
-    class Operation
-      def set_adapter(adapter)
-        @adapter = adapter
-      end
-
-      def create_security_group(sg)
-        attributes = {name: sg.name, description: sg.description, tenant_id: sg.tenant_id}
-        security_group_id = @adapter.create_security_group(attributes)
-
-        #delete default rule
-        delete_sg = sg.clone
-        delete_sg.set_default_rules
-
-        delete_security_rule(delete_sg) unless @adapter.instance_of?(Kakine::Adapter::Mock)
-        security_group_id
-      end
-
-      def delete_security_group(sg)
-        security_group = Kakine::Resource.security_group(sg.tenant_name, sg.name)
-        @adapter.delete_security_group(security_group.id)
-      end
-
-      def create_security_rule(sg, security_group_id=nil)
-        if security_group_id.nil?
-          security_group = Kakine::Resource.security_group(sg.tenant_name, sg.name)
-          security_group_id = security_group.id
-        end
-        sg.rules.each do |rule|
-          @adapter.create_rule(security_group_id, rule["direction"], rule)
-        end if sg.has_rules?
-      end
-
-      def delete_security_rule(sg)
-        security_group = Kakine::Resource.security_group(sg.tenant_name, sg.name)
-        sg.rules.each do |rule|
-          security_group_rule = Kakine::Resource.security_group_rule(security_group, rule)
-          @adapter.delete_rule(security_group_rule.id)
-        end if sg.has_rules?
-      end
-    end
-  end
-end

data/lib/kakine/diff_parser.rb

@@ -1,88 +0,0 @@
-module Kakine
- class DiffParser
-    @diff = ""
-    class << self
-      def parse_parameters(tenant_name, diff)
-        @diff = diff
-
-        registered_sg = Kakine::Resource.security_groups_hash(tenant_name)
-        if ["+", "-"].include?(parse_transaction_type)
-          if unit_is_security_group?
-            rules = parse_security_group["rules"]
-            description = parse_security_group["description"]
-          elsif unit_is_security_rule?
-            rules = [parse_security_group_rule]
-            description = registered_sg[parse_security_group_name]["description"]
-          elsif unit_is_description?
-            raise "description is not exists"
-          end
-        else
-          regex_update_description = /^[\w-]+\.description$/
-          regex_update_rules       = /^[\w-]+\.rules$/
-          regex_update_attr        = /^[\w-]+.[\w]+\[(\d)\].([\w]+)$/
-
-          if parse_target_object_name.match(regex_update_description)
-            rules = registered_sg[parse_security_group_name]["rules"]
-            description = parse_after_description
-          elsif  parse_target_object_name.match(regex_update_rules)
-            rules = parse_after_rules
-            description = registered_sg[parse_security_group_name]["description"]
-          elsif m = parse_target_object_name.match(regex_update_attr)
-            rules = [registered_sg[parse_security_group_name]["rules"][m[1].to_i]]
-            prev_rules = Marshal.load(Marshal.dump(rules)) # backup before value
-            rules[0][m[2]] = parse_after_attr
-            description = registered_sg[parse_security_group_name]["description"]
-          end
-        end
-        rules ||= []
-
-        {
-          target_object_name: parse_target_object_name,
-          name: parse_security_group_name,
-          transaction_type: parse_transaction_type,
-          tenant_id: Kakine::Resource.tenant(tenant_name).id,
-          tenant_name: tenant_name,
-          description: description,
-          rules: rules,
-          prev_rules: prev_rules
-        }
-      end
-
-      def parse_security_group_name
-        parse_target_object_name.split(/[\.\[]/, 2)[0]
-      end
-
-
-      def parse_transaction_type
-        @diff[0]
-      end
-
-      def parse_target_object_name
-        @diff[1]
-      end
-
-      def parse_security_group
-        @diff[2]
-      end
-      alias :parse_security_group_rule :parse_security_group
-
-      def parse_after_attr
-        @diff[3]
-      end
-      alias :parse_after_description :parse_after_attr
-      alias :parse_after_rules       :parse_after_attr
-
-      def unit_is_security_group?
-        parse_security_group && parse_security_group["rules"]
-      end
-
-      def unit_is_security_rule?
-        !(parse_security_group_rule.nil? || unit_is_description?)
-      end
-
-      def unit_is_description?
-        parse_target_object_name.index('description')
-      end
-    end
-  end
-end

data/lib/kakine/hash_sort.rb

@@ -1,13 +0,0 @@
-class Hash
-  def sg_rules_sort
-    self.each do |sg|
-      sg[1]['rules'].sort_by! do |rule|
-        rule.inject(0) do |ascii,(k,v)|
-          ascii += v.ord.to_i unless v.nil?
-          ascii
-        end
-      end unless sg[1].nil? || sg[1]['rules'].nil?
-    end
-    Hash[self]
-  end
-end