aws-edges 0.8

data/lib/aws-edges/ec2.rb

@@ -0,0 +1,53 @@
+module AWSEdges 
+  class EC2 
+    attr_reader :nodes
+
+    def initialize(describe_instances)
+      @nodes = Array.new
+      describe_instances[:reservation_set].each{|r| r[:instances_set].each{|i|
+        @nodes.push({
+          :instance_id => i[:instance_id],
+          :instance_type => i[:instance_type],
+          :kernel_id => i[:kernel_id],
+          :ramdisk_id => i[:ramdisk_id],
+          :architecture => i[:architecture],
+          :ebs_optimized => i[:ebs_optimized],
+          :root_device_type => i[:root_device_type],
+          :root_device_name => i[:root_device_name],
+          :virtualization_type => i[:virtualization_type],
+          :hypervisor => i[:hypervisor],
+          :source_dest_check => i[:source_dest_check],
+          :image_id => i[:image_id],
+          :vpc_id => i[:vpc_id],
+          :subnet_id => i[:subnet_id],
+          :public_dns_name => i[:dns_name],
+          :public_ip_address => i[:ip_address],
+          :private_dns_name => i[:private_dns_name],
+          :private_ip_address => i[:private_ip_address],
+          :availability_zone => i[:placement][:availability_zone],
+          :security_groups => []
+        })
+
+        security_groups = Array.new
+        i[:group_set].each{|g|
+          security_groups.push({
+            :group_name => g[:group_name],
+            :group_id => g[:group_id]
+          })
+        }
+        @nodes[@nodes.length - 1][:security_groups] = security_groups
+      }}
+    end
+
+    def self.supported_fields
+      [
+        "instance_id", "kernel_id", "ramdisk_id", "architecture",
+        "ebs_optimized", "root_device_type", "root_device_name",
+        "virtualization_type", "hypervisor", "source_dest_check", "image_id", "vpc_id",
+        "subnet_id", "public_dns_name", "public_ip_address", "private_dns_name", 
+        "private_ip_address", "availability_zone", "security_groups-group_name",
+        "security_groups-group_id"
+      ]
+    end
+  end
+end

data/lib/aws-edges/graph.rb

@@ -0,0 +1,190 @@
+# TODO -list
+# add edge shape/color attribute support
+# add node (ie path)  color/shape support
+# allow control of node_attribs << filled
+# add xref support for edge nodes (eg:)
+#   - ec2_private_ip_address
+#   - vpc_cidr_block
+# change edge to node if point is missing
+# add support for nested values
+#   - redshift_cluster_nodes-*
+
+module AWSEdges
+  class Graph
+    attr_reader :format
+    
+    def initialize(config_data, aws_data)
+      @config = config_data
+      @aws = aws_data
+    end
+
+    ##
+    # Generate the graphviz digraph statement for edges
+    #
+    def map_edges(from, from_color, from_shape, to, to_color, to_shape)
+      cmd_string = ""  
+      from_prefix, from_node = $1, $2 if from =~ /^(\w+?)_(.+)/
+      to_prefix, to_node = $1, $2 if to =~ /^(\w+?)_(.+)/
+      @aws[:"#{from_prefix}"].each do |node|
+            if from_node.include?('-')
+              (parent, child) = from_node.split('-')
+              node[:"#{parent}"].each do |i|
+                cmd_string += " edge " + '"' + 
+                i[:"#{child}"].to_s + '","' +
+                node[:"#{to_node}"].to_s + '";'
+
+                unless from_color.nil?
+                  unless from_color.empty?
+                    cmd_string += assign_color_attribute(from_color, i[:"#{child}"])
+                  end
+                end
+
+                unless from_shape.nil?
+                  unless from_shape.empty?
+                    cmd_string += assign_shape_attribute(from_shape, i[:"#{child}"])
+                  end
+                end
+
+                unless to_color.nil?
+                  unless to_color.empty?
+                    cmd_string += assign_color_attribute(to_color, node[:"#{to_node}"]) 
+                  end
+                end
+
+                unless to_shape.nil?
+                  unless to_shape.empty?
+                    cmd_string += assign_shape_attribute(to_shape, node[:"#{to_node}"]) 
+                  end
+                end
+
+              end unless node[:"#{parent}"].nil?
+            elsif to_node.include?('-')
+              (parent, child) = to_node.split('-')
+              node[:"#{parent}"].each do |i|
+                cmd_string += " edge " + '"' + 
+                node[:"#{from_node}"].to_s + '","' +
+                i[:"#{child}"].to_s + '";'
+
+                unless from_color.nil?
+                  unless from_color.empty?
+                    cmd_string += assign_color_attribute(from_color, node[:"#{from_node}"])
+                  end
+                end
+
+                unless from_shape.nil?
+                  unless from_shape.empty?
+                    cmd_string += assign_shape_attribute(from_shape, node[:"#{from_node}"])
+                  end
+                end
+
+                unless to_color.nil?
+                  unless to_color.empty?
+                    cmd_string += assign_color_attribute(to_color, i[:"#{child}"]) 
+                  end
+                end
+
+                unless to_shape.nil?
+                  unless to_shape.empty?
+                    cmd_string += assign_shape_attribute(to_shape, i[:"#{child}"]) 
+                  end
+                end
+
+              end unless node[:"#{parent}"].nil?
+            else
+              cmd_string += " edge " + '"' + 
+              node[:"#{from_node}"].to_s + '","' + 
+              node[:"#{to_node}"].to_s + '";'
+
+              unless from_color.nil?
+                unless from_color.empty?
+                  cmd_string += assign_color_attribute(from_color, node[:"#{from_node}"])
+                end
+              end
+
+              unless from_shape.nil?
+                unless from_shape.empty?
+                  cmd_string += assign_shape_attribute(from_shape, node[:"#{from_node}"])
+                end
+              end
+
+              unless to_color.nil?
+                unless to_color.empty?
+                  cmd_string += assign_color_attribute(to_color, node[:"#{to_node}"]) 
+                end
+              end
+
+              unless to_shape.nil?
+                unless to_shape.empty?
+                  cmd_string += assign_shape_attribute(to_shape, node[:"#{to_node}"]) 
+                end
+              end
+
+            end
+      end
+      cmd_string
+    end
+
+    ##
+    # TODO: assign colors
+    # all eg: edge_attribs << orange
+    def assign_color_attribute(color, edge)
+      return "#{color} << node(\"#{edge}\");"
+    end
+
+    ##
+    # TODO: assign shapes
+    # all eg: edge_attribs << triangle
+    def assign_shape_attribute(shape, edge)
+      return "#{shape} << node(\"#{edge}\");"
+    end
+
+    ##
+    # Dynamically create graphviz digraph statements
+    # based on the config file input
+    def generate_graph_statements(config)
+      cmd_string = ""
+      config.each do |key,value|
+        if key == "cluster"
+          cmd_string += "cluster \"#{value['label']}\" do " 
+          cmd_string += "label \"#{value['label']}\";"
+          cmd_string += generate_graph_statements(value)
+          cmd_string += " end;"
+        elsif key == "edges"
+          value.each do |e|
+            cmd_string += map_edges(
+              e['from'], e['from_color'], e['from_shape'], 
+              e['to'], e['to_color'], e['to_shape']
+            )
+          end
+        end
+      end
+      cmd_string
+    end
+
+    ##
+    # Main method for creating graphviz digraphs from the
+    # parsed config file
+    def create_graph()
+      ##
+      # default to png output format
+      # for a full list: http://www.graphviz.org/doc/info/output.html
+      format = @config.delete('save_as')
+      format = "png" unless format
+      graph_name = @config.delete('name').gsub(/\s+/,'_')
+      rotate_layout = true if @config['rotate'] == true
+      cmds = generate_graph_statements(@config)
+      begin
+      digraph do
+        node_attribs << filled
+        rotate if rotate_layout
+        boxes
+        eval cmds
+        save "#{graph_name}", "#{format}"  
+      end
+      rescue Exception => e
+        puts "Failed to create the graph: #{e}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/aws-edges/iam.rb

@@ -0,0 +1,91 @@
+module AWSEdges
+  class IAM
+    attr_reader :nodes
+
+    def initialize(iam)
+      @nodes = Array.new
+
+      # get IAM groups
+      iam.list_groups[:groups].each{|g|
+        @nodes.push({
+          :group_name => g[:group_name],
+          :group_id => g[:group_id],
+          :group_arn => g[:arn],
+          :group_create_date => g[:create_date],
+          :users => [],
+          :group_policies => []
+        }) 
+
+        # get group members
+        assigned_users = Array.new
+        iam.get_group(options = {:group_name => g[:group_name]})[:users].each {|u|
+          assigned_users.push({
+            :user_name => u[:user_name],
+            :user_id => u[:user_id],
+            :arn => u[:arn],
+            :path => u[:path],
+            :create_date => u[:create_date],
+          })
+        }
+        @nodes[@nodes.length - 1][:users] = assigned_users
+
+        # get group policies
+        assigned_policies = Array.new
+        iam.list_group_policies(options = {:group_name => g[:group_name]})[:policy_names].each {|p|
+          assigned_policies.push({
+            :policy_name => p
+          })
+        }
+        @nodes[@nodes.length - 1][:group_policies] = assigned_policies
+      }
+
+      # get IAM users
+      iam.list_users[:users].each{|u|
+        @nodes.push({
+          :user_name => u[:user_name],
+          :user_id => u[:user_id],
+          :user_arn => u[:arn],
+          :user_path => u[:path],
+          :user_create_date => u[:create_date],
+          :groups => [],
+          :user_policies => []
+        })
+
+        # get membership
+        assigned_groups = Array.new
+        iam.list_groups_for_user(options = {:user_name => u[:user_name]})[:groups].each {|g|
+          assigned_groups.push({
+            :path => g[:path],
+            :group_name => g[:group_name],
+            :group_id => g[:group_id],
+            :arn => g[:arn],
+            :create_date => g[:create_date]
+          }) 
+        }
+        @nodes[@nodes.length - 1][:groups] = assigned_groups
+
+        # get user policies
+        assigned_policies = Array.new
+        iam.list_user_policies(options = {:user_name => u[:user_name]})[:policy_names].each {|p|
+          assigned_policies.push({
+            :policy_name => p
+          })
+        }
+        @nodes[@nodes.length - 1][:user_policies] = assigned_policies
+      }
+    end
+
+    def self.supported_fields
+      [ "group_path", "group_name", "group_id", "group_arn",
+        "group_create_date", "users-path", "users-user_name",
+        "users-user_id", "users-arn", "users-create_date",
+        "group_policies-policy_name",
+        "user_path", "user_name", "user_id", "user_arn",
+        "user_create_date", "groups-path", "groups-group_name",
+        "groups-group_id", "groups-arn", "groups-create_date",
+        "user_policies-policy_name"
+      ]
+    end
+  end
+
+end

data/lib/aws-edges/rds.rb

@@ -0,0 +1,32 @@
+module AWSEdges
+  class RDS 
+    attr_reader :nodes
+
+    def initialize(describe_db_instances)
+      @nodes = Array.new
+      describe_db_instances[:db_instances].each{|i|
+        @nodes.push({
+          :db_name => i[:db_name],
+          :db_engine => i[:engine],
+          :vpc_id => i[:db_subnet_group][:vpc_id],
+          :subnet_group_name => i[:db_subnet_group][:db_subnet_group_name],
+          :availability_zone => i[:availability_zone],
+          :secondary_availability_zone => i[:secondary_availability_zone],
+          :multi_az => i[:multi_az],
+          :db_engine_version => i[:engine_version],
+          :iops => i[:iops],
+          :publicly_accessible => i[:publicly_accessible]
+        })
+      }
+    end
+
+    def self.supported_fields
+      [
+        "db_name", "db_engine", "vpc_id",
+        "subnet_group_name", "availability_zone",
+        "secondary_availability_zone", "multi_az",
+        "db_engine_version", "iops", "publicly_accessible"
+      ]
+    end
+  end
+end

data/lib/aws-edges/redshift.rb

@@ -0,0 +1,40 @@
+module AWSEdges
+  class Redshift 
+    attr_reader :nodes
+
+    def initialize(describe_clusters)
+      @nodes = Array.new
+      describe_clusters[:clusters].each{|c|
+        @nodes.push({
+          :db_name => c[:db_name],
+          :vpc_id => c[:vpc_id],
+          :availability_zone => c[:availability_zone],
+          :subnet_group_name => c[:cluster_subnet_group_name],
+          :publicly_accessible => c[:publicly_accessible],
+          :cluster_version => c[:cluster_version],
+          :encrypted => c[:encrypted],
+          :cluster_nodes => []
+        })
+
+        cluster_nodes = Array.new
+        c[:cluster_nodes].each{|n|
+          cluster_nodes.push({
+            :node_role => n[:role_name],
+            :public_ip_address => n[:public_ip_address],
+            :private_ip_address => n[:private_ip_address]
+          })
+        }
+        @nodes[@nodes.length - 1][:cluster_nodes] = cluster_nodes
+      }
+    end
+
+    def self.supported_fields
+      [
+        "db_name", "vpc_id", "availability_zone",
+        "subnet_group_name", "publicly_accessible", "cluster_version",
+        "encrypted", "cluster_nodes-node_role",
+        "cluster_nodes-public_ip_address", "cluster_nodes-private_ip_address"
+      ]
+    end
+  end
+end

data/lib/aws-edges/subnet.rb

@@ -0,0 +1,21 @@
+module AWSEdges
+  class Subnet
+    attr_reader :nodes
+
+    def initialize(describe_subnets)
+      @nodes = Array.new
+      describe_subnets[:subnet_set].each{|s|
+        @nodes.push({
+          :vpc_id => s[:vpc_id],
+          :cidr_block => s[:cidr_block],
+          :availability_zone => s[:availability_zone],
+          :subnet_id => s[:subnet_id]
+        })
+      }
+    end
+
+    def self.supported_fields
+      [ "vpc_id", "cidr_block", "availability_zone", "subnet_id" ]
+    end
+  end
+end

data/lib/aws-edges/version.rb

@@ -0,0 +1,5 @@
+module AWSEdges
+  ##
+  # returns the version of this module
+  VERSION = '0.8'
+end

data/lib/aws-edges/vpc.rb

@@ -0,0 +1,19 @@
+module AWSEdges
+  class VPC
+    attr_reader :nodes
+
+    def initialize(describe_vpcs)
+      @nodes = Array.new
+      describe_vpcs[:vpc_set].each{|v|
+        @nodes.push({
+          :vpc_id => v[:vpc_id],
+          :cidr_block => v[:cidr_block]
+        })
+      }
+    end
+
+    def self.supported_fields
+      [ "vpc_id", "cidr_block" ]
+    end
+  end
+end