hugo 0.1.0

data/lib/hugo/aws/ec2.rb

@@ -0,0 +1,112 @@
+module Hugo
+  module Aws
+    class Ec2
+    
+      ACCESS_KEY = ENV['AMAZON_ACCESS_KEY_ID'] 
+      SECRET_KEY = ENV['AMAZON_SECRET_ACCESS_KEY']
+      KEY_NAME = ENV['KEY_NAME']
+    
+      AMI = ENV['EC2_AMI_ID'] || 'ami-1515f67c'
+      ZONE = "us-east-1c"
+      TYPE = "m1.small"
+  
+      attr_accessor :name, :uri, :type, :zone, :image_id, :key_name, :create_time, :status, :security_group
+
+      def initialize(options = {})
+        set_attributes(options)
+      end
+      
+      def set_attributes(options = {})
+        @name = options["instanceId"] 
+      
+        if options["placement"] and options["placement"]["availabilityZone"]
+          @zone = options["placement"]["availabilityZone"] 
+        else
+          @zone = ZONE
+        end
+      
+        @uri = options["dnsName"] || ""
+        @type = options["instanceType"] || TYPE
+        @image_id = options["imageId"] || AMI
+        @create_time = options["launchTime"] || nil
+      
+        @key_name = options[:key_name] || options["keyName"] || KEY_NAME
+        if options["instanceState"] and options["instanceState"]["name"]
+          @status = options["instanceState"]["name"]
+        else
+          @status = "unknown"
+        end
+
+        # @security_group = options[:security_group] || nil
+        # if options["groupSet"] and options["groupSet"]["item"] and options["groupSet"]["item"][0]
+        #   @security_group = options["groupSet"]["item"][0]["groupId"]
+        # end
+        
+      end
+      
+    
+      def create
+        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        result = @ec2.run_instances(:image_id => self.image_id, :key_name => self.key_name, 
+          :max_count => 1,
+          :availability_zone => self.zone) unless self.create_time
+        set_attributes(result.instancesSet.item[0]) if result.instancesSet.item[0]
+        self
+      end
+    
+      def destroy
+        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @ec2.terminate_instances(:instance_id => self.name)
+      end
+    
+      def save
+        self.create
+      end
+    
+      def ssh(commands, dna=nil, key_pair_file=nil)
+        raise ArgumentError.new("Key Pair File is required") if key_pair_file.nil?
+        Net::SSH.start(self.uri, "ubuntu", :keys => key_pair_file) do |ssh|
+          if dna
+            ssh.exec!("echo \"#{dna.to_json.gsub('"','\"')}\" > ~/dna.json")
+          end
+          commands.each do |cmd|
+            puts ssh.exec!(cmd)
+          end
+        end
+      end
+    
+      def self.find_or_create_security_group(name, description)
+        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        begin
+          @security_groups = @ec2.describe_security_groups(:group_name => name)
+        rescue
+          @security_groups = @ec2.create_security_group(:group_name => name, :group_description => description)
+        end
+        @security_groups
+      end
+
+      def self.destroy_security_group(name)
+        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @ec2.delete_security_group(:group_name => name)
+      end
+
+      def self.all
+        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @ec2.describe_instances().reservationSet.item[0].instancesSet.item.map { |i| self.new(i) }
+      end
+    
+      def self.find(instance)
+        @ec2 = AWS::EC2::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        self.new(@ec2.describe_instances(:instance_id => instance).reservationSet.item[0].instancesSet.item[0])
+      end
+    
+      def self.find_or_create(options)
+        if options[:name]
+          self.find(options[:name]) 
+        else
+          self.new(options).create
+        end
+      end
+    end
+  end
+end

data/lib/hugo/aws/elb.rb

@@ -0,0 +1,101 @@
+module Hugo
+  module Aws
+    class Elb
+    
+      ACCESS_KEY = ENV['AMAZON_ACCESS_KEY_ID'] 
+      SECRET_KEY = ENV['AMAZON_SECRET_ACCESS_KEY'] 
+      ZONES = ["us-east-1c"]
+      LISTENERS = [{"InstancePort"=>"8080", "Protocol"=>"HTTP", "LoadBalancerPort"=>"80"}, 
+        {"InstancePort"=>"8443", "Protocol"=>"TCP", "LoadBalancerPort"=>"443"}]
+    
+      attr_accessor :name, :uri, :listeners, :instances, :zones, :create_time
+    
+      def initialize(options = {} )
+        @name = options[:name] || options["LoadBalancerName"]
+    
+        @uri = options["DNSName"] if options["DNSName"]
+            
+        if options["Instances"] and options["Instances"]["member"]
+          @instances = options["Instances"]["member"].map { |i| i.InstanceId }
+        else
+          @instances = []
+        end
+        if options["AvailabilityZones"] and options["AvailabilityZones"]["member"]
+          @zones = options["AvailabilityZones"]["member"]
+        else
+          @zones = options[:zones] || ZONES
+        end
+        if options["Listeners"] and options["Listeners"]["member"]
+          @listeners = options["Listeners"]["member"]
+        else
+          @listeners = options[:listeners] || LISTENERS
+        end
+        if options["CreatedTime"]
+          @create_time = options["CreatedTime"]
+        end
+      end
+    
+      def create
+        @elb = AWS::ELB::Base.new(:access_key_id => Hugo::Aws::Elb::ACCESS_KEY, :secret_access_key => Hugo::Aws::Elb::SECRET_KEY)
+        @elb.create_load_balancer(
+          :load_balancer_name => self.name,
+          :listeners => self.listeners,
+          :availability_zones => self.zones
+        ) unless self.create_time
+        self
+      end
+    
+      def destroy
+        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @elb.delete_load_balancer(:load_balancer_name => self.name)
+      end
+    
+      def save
+        self.create
+      end
+    
+      def add(instance)
+        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @elb.register_instances_with_load_balancer(
+          :instances => [instance],
+          :load_balancer_name => @name)
+        @instances << instance
+        self
+      end
+    
+      def remove(instance)
+        
+        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @elb.deregister_instances_from_load_balancer(
+          :instances => [instance],
+          :load_balancer_name => @name)
+        @instances = @instances - [instance]
+        self
+      end
+    
+      def self.all
+        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        instances = @elb.describe_load_balancers().DescribeLoadBalancersResult.LoadBalancerDescriptions.member      
+        instances.map { |i| self.new(i) }
+      end
+    
+      def self.find(balancer)
+        @elb = AWS::ELB::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        
+        result = nil
+    
+        @elb.describe_load_balancers().DescribeLoadBalancersResult.LoadBalancerDescriptions.member.each do |m|
+          result = self.new(m) if m.LoadBalancerName == balancer
+        end
+        
+        result
+      rescue
+        nil
+      end
+    
+      def self.find_or_create(options)
+        self.find(options[:name]) || self.new(options).create
+      end
+    end
+  end
+end

data/lib/hugo/aws/rds.rb

@@ -0,0 +1,120 @@
+module Hugo
+  module Aws
+    class Rds
+    
+      ACCESS_KEY = ENV['AMAZON_ACCESS_KEY_ID'] 
+      SECRET_KEY = ENV['AMAZON_SECRET_ACCESS_KEY'] 
+      DEFAULT_SIZE = 5
+      INSTANCE_CLASS = "db.m1.small"
+      ZONE = "us-east-1c"
+    
+      attr_accessor :db, :uri, :server, :user, :password, :instance_class, 
+                    :zone, :size, :status, :create_time, :db_security_group
+    
+      def initialize(options={})
+        # create instance
+        
+        @server = options[:server] || options["DBInstanceIdentifier"]
+        @db = options[:name] || options["DBName"]
+        @user = options[:user] || options["MasterUsername"]
+        @password = options[:password] if options[:password]
+        @size = options[:size] || options["AllocatedStorage"] || DEFAULT_SIZE
+        @instance_class = options[:instance_class] || options["DBInstanceClass"] || INSTANCE_CLASS
+        @zone = options[:zone] || options["AvailabilityZone"] || ZONE
+        @status = options["DBInstanceStatus"] || "pending"
+        @create_time = options["InstanceCreateTime"] || nil
+        if options["Endpoint"] and options["Endpoint"]["Address"]
+          @uri = options["Endpoint"]["Address"] || nil 
+        end
+        @db_security_group = options[:db_security_group] || "default"
+        if options["DBSecurityGroups"] and options["DBSecurityGroups"]["DBSecurityGroup"]
+          @db_security_group = options["DBSecurityGroups"]["DBSecurityGroup"]["DBSecurityGroupName"] 
+        end
+        
+      end
+    
+      def create
+        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)      
+        
+        # TODO Create DB Security Group wheh Amazon Bug Fixed! -tnw
+        # if @db_security_group
+        #   find_or_create_db_security_group(@db_security_group, @db_security_group)
+        # end
+        
+        @rds.create_db_instance(
+          :db_instance_identifier => self.server,
+          :allocated_storage => self.size,
+          :db_instance_class => self.instance_class,
+          :engine => "MySQL5.1",
+          :master_username => self.user,
+          :master_user_password => self.password,
+          :db_name => self.db,
+          :availability_zone => self.zone
+          #, :db_security_groups => @db_security_group
+          ) unless self.create_time
+        self
+      end
+    
+      def save
+        create 
+      end
+    
+      def destroy
+        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)      
+        @rds.delete_db_instance(:db_instance_identifier => self.server, :skip_final_snapshot => true)
+      end
+    
+      def self.all
+        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        instances = @rds.describe_db_instances.DescribeDBInstancesResult.DBInstances.DBInstance
+      
+        if instances.kind_of?(Array)
+          #instances.map { |i| self.get_from_aws(i) }
+          instances.map { |i| self.new(i) }
+        else
+           #self.get_from_aws(instances)      
+           [ self.new(instances) ]
+        end
+      end
+    
+      def self.find(instance)
+        # find instance
+        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @rds_instance = @rds.describe_db_instances(:db_instance_identifier => instance)
+        instance_desc = @rds_instance.DescribeDBInstancesResult.DBInstances.DBInstance  
+        # initialize Hugo::Rds Object with instance hash
+        self.new(instance_desc)
+      rescue
+        # AWS Can't find db instance called ????
+        nil
+      end
+
+      def self.find_or_create(options)
+        rds = self.find(options[:server]) || self.new(options).create
+        rds.password = options[:password]
+        rds
+      end
+
+      def authorize_security_group(db_sec, ec2_sec, owner_id)
+        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @rds.authorize_db_security_group(:db_security_group_name => db_sec, :ec2_security_group_name => ec2_sec, :ec2_security_group_owner_id => owner_id)
+      end
+    
+      def find_or_create_db_security_group(name, description)
+        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        begin
+          @security_groups = @rds.describe_db_security_groups(:db_security_group_name => name)
+        rescue
+          @security_groups = @rds.create_db_security_group(:db_security_group_name => name, :db_security_group_description => description)
+        end
+        puts @security_groups
+        @security_groups
+      end
+
+      def destroy_db_security_group(name)
+        @rds = AWS::RDS::Base.new(:access_key_id => ACCESS_KEY, :secret_access_key => SECRET_KEY)
+        @rds.delete_db_security_group(:db_security_group_name => name)
+      end
+    end
+  end
+end

data/lib/hugo/balancer.rb

@@ -0,0 +1,59 @@
+module Hugo; end
+  
+class Hugo::Balancer
+  include Singleton
+  include Hugo::Mixin::ParamsValidate
+  
+  DEFAULT_ZONE = 'us-east-1c'
+  DEFAULT_PORT = '8080'
+  DEFAULT_WEB = '80'
+  DEFAULT_TYPE = 'http'
+  DEFAULT_SSL_PORT = '8443'
+  DEFAULT_SSL_WEB = '443'
+  
+  def initialize
+    zone DEFAULT_ZONE
+    port DEFAULT_PORT
+    web DEFAULT_WEB
+    ssl_port DEFAULT_SSL_PORT
+    ssl_web DEFAULT_SSL_WEB
+    type DEFAULT_TYPE
+  end
+  
+  def deploy
+    Hugo::Aws::Elb.find_or_create(:name => name,
+                            :zones => zone,
+                            :listeners => [{ :instance_port => port, :protocol =>"HTTP", :load_balancer_port => web}, 
+                              { :instance_port => ssl_port, :protocol =>"TCP", :load_balancer_port => ssl_web}]
+    )
+  end
+  
+  def name(arg=nil)
+    set_or_return(:name, arg, :kind_of => [String])     
+  end
+  
+  def zone(arg=nil)
+    set_or_return(:zone, arg, :kind_of => [String])     
+  end
+
+  def port(arg=nil)
+    set_or_return(:port, arg, :kind_of => [String])     
+  end
+
+  def web(arg=nil)
+    set_or_return(:web, arg, :kind_of => [String])     
+  end
+
+  def type(arg=nil)
+    set_or_return(:type, arg, :kind_of => [String])     
+  end
+
+  def ssl_port(arg=nil)
+    set_or_return(:ssl_port, arg, :kind_of => [String])     
+  end
+  
+  def ssl_web(arg=nil)
+    set_or_return(:ssl_web, arg, :kind_of => [String])     
+  end
+  
+end

data/lib/hugo/cloud.rb

@@ -0,0 +1,113 @@
+module Hugo; end
+  
+class Hugo::Cloud
+  include Singleton
+  include Hugo::Mixin::ParamsValidate
+  
+                      
+  def initialize
+
+  end
+
+  def database(db_name, &block)
+    database = Hugo::Database.instance
+    
+    database.db_security_group name
+    database.server name
+    database.name db_name
+    
+    database.instance_eval(&block) if block_given? 
+    db database.deploy 
+    
+    
+  end
+  
+  def balancer(&block)
+    balancer = Hugo::Balancer.instance
+    balancer.name name
+    balancer.instance_eval(&block) if block_given? 
+    lb balancer.deploy 
+  end
+  
+  def app(name, &block)
+    app_info = Hugo::App.instance
+    app_info.name name
+    app_info.lb lb
+    app_info.db db
+    app_info.cloud_name name
+    app_info.instance_eval(&block) if block_given? 
+    cloud_app app_info
+    
+  end
+  
+  def deploy
+    if cloud_app
+      cloud_app.setup
+      cloud_app.deploy
+    end
+    
+  end
+  
+  def delete
+    [db, cloud_app, lb].each do |s|
+      s.destroy if s
+    end
+  end
+  
+  
+    
+  def print
+    if db
+      puts <<REPORT
+------------------------    
+DATABASE: #{db.db}
+  User: #{db.user}
+  Password: #{db.password}
+  Uri: #{db.uri}
+REPORT
+    end
+    
+    if lb
+      puts <<REPORT
+-----------------------  
+Balancer: #{lb.name}
+  Uri: #{lb.uri}
+  Servers: #{lb.instances.length}
+REPORT
+  
+      lb.instances.each do |i|
+        ec2 = Hugo::Aws::Ec2.find(i)
+        puts <<REPORT
+-----------------------      
+Id: #{ec2.name}
+Uri: #{ec2.uri}
+Type: #{ec2.type}
+Zone: #{ec2.zone}
+
+REPORT
+      end
+    end
+
+  end
+
+  def name(arg=nil)
+    set_or_return(:name, arg, :kind_of => [String])
+  end
+  
+  def db(arg=nil)
+    set_or_return(:db, arg, :kind_of => [Hugo::Aws::Rds])
+  end
+  
+  def lb(arg=nil)
+    set_or_return(:lb, arg, :kind_of => [Hugo::Aws::Elb])    
+  end
+
+  def cloud_app(arg=nil)
+    set_or_return(:cloud_app, arg, :kind_of => [Hugo::App])    
+  end
+  
+  
+  
+
+
+end