hugo 0.1.0

data/lib/hugo/database.rb

@@ -0,0 +1,58 @@
+module Hugo; end
+
+class Hugo::Database
+  include Singleton
+  include Hugo::Mixin::ParamsValidate
+  
+  DEFAULT_SERVER = "DEFAULT"
+  DEFAULT_SIZE = 5
+  DEFAULT_ZONE = 'us-east-1c'
+  
+
+  def initialize
+    size DEFAULT_SIZE
+    zone DEFAULT_ZONE
+    server DEFAULT_SERVER
+    db_security_group "default"
+  end
+  
+  def deploy
+    Hugo::Aws::Rds.find_or_create( :name => name,
+                              :server => server,
+                              :user => user,
+                              :password => password,
+                              :size => size,
+                              :zone => zone,
+                              :db_security_group => db_security_group
+                               )
+  end
+  
+  def name(arg=nil)
+    set_or_return(:name, arg, :kind_of => [String])     
+  end
+
+  def server(arg=nil)
+    set_or_return(:server, arg, :kind_of => [String])     
+  end
+
+  def user(arg=nil)
+    set_or_return(:user, arg, :kind_of => [String])     
+  end
+
+  def password(arg=nil)
+    set_or_return(:password, arg, :kind_of => [String])     
+  end
+
+  def size(arg=nil)
+    set_or_return(:size, arg, :kind_of => [Integer])     
+  end
+
+  def zone(arg=nil)
+    set_or_return(:zone, arg, :kind_of => [String])     
+  end
+
+  def db_security_group(arg=nil)
+    set_or_return(:db_security_group, arg, :kind_of => [String])     
+  end
+    
+end

data/lib/hugo/mixin/params_validate.rb

@@ -0,0 +1,197 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+ 
+module Hugo
+  module Mixin
+    module ParamsValidate
+      
+      # Takes a hash of options, along with a map to validate them.  Returns the original
+      # options hash, plus any changes that might have been made (through things like setting
+      # default values in the validation map)
+      #
+      # For example:
+      #
+      #   validate({ :one => "neat" }, { :one => { :kind_of => String }})
+      # 
+      # Would raise an exception if the value of :one above is not a kind_of? string.  Valid
+      # map options are:
+      #
+      # :default:: Sets the default value for this parameter.
+      # :callbacks:: Takes a hash of Procs, which should return true if the argument is valid.  
+      #              The key will be inserted into the error message if the Proc does not return true:
+      #                 "Option #{key}'s value #{value} #{message}!"
+      # :kind_of:: Ensure that the value is a kind_of?(Whatever).  If passed an array, it will ensure 
+      #            that the value is one of those types.
+      # :respond_to:: Ensure that the value has a given method.  Takes one method name or an array of
+      #               method names.
+      # :required:: Raise an exception if this parameter is missing. Valid values are true or false, 
+      #             by default, options are not required.
+      # :regex:: Match the value of the paramater against a regular expression.
+      # :equal_to:: Match the value of the paramater with ==.  An array means it can be equal to any
+      #             of the values.
+      def validate(opts, map)
+        #--
+        # validate works by taking the keys in the validation map, assuming it's a hash, and
+        # looking for _pv_:symbol as methods.  Assuming it find them, it calls the right 
+        # one.  
+        #++
+        raise ArgumentError, "Options must be a hash" unless opts.kind_of?(Hash)
+        raise ArgumentError, "Validation Map must be a hash" unless map.kind_of?(Hash)   
+        
+        map.each do |key, validation|
+          unless key.kind_of?(Symbol) || key.kind_of?(String)
+            raise ArgumentError, "Validation map keys must be symbols or strings!"
+          end
+          case validation
+          when true
+            _pv_required(opts, key)
+          when false
+            true
+          when Hash
+            validation.each do |check, carg|
+              check_method = "_pv_#{check.to_s}"
+              if self.respond_to?(check_method, true)
+                self.send(check_method, opts, key, carg)
+              else
+                raise ArgumentError, "Validation map has unknown check: #{check}"
+              end
+            end
+          end
+        end
+        opts
+      end
+          
+      def set_or_return(symbol, arg, validation)
+        iv_symbol = "@#{symbol.to_s}".to_sym
+        map = {
+          symbol => validation
+        }
+        if arg == nil
+          self.instance_variable_get(iv_symbol)
+        else
+          validate({ symbol => arg }, { symbol => validation })
+          self.instance_variable_set(iv_symbol, arg)
+        end
+      end
+            
+      private
+      
+        # Return the value of a parameter, or nil if it doesn't exist.
+        def _pv_opts_lookup(opts, key)
+          if opts.has_key?(key.to_s)
+            opts[key.to_s]
+          elsif opts.has_key?(key.to_sym)
+            opts[key.to_sym]
+          else
+            nil
+          end
+        end
+        
+        # Raise an exception if the parameter is not found.
+        def _pv_required(opts, key, is_required=true)
+          if is_required
+            if opts.has_key?(key.to_s) || opts.has_key?(key.to_sym)
+              true
+            else
+              raise ArgumentError, "Required argument #{key} is missing!"
+            end
+          end
+        end
+        
+        def _pv_equal_to(opts, key, to_be)
+          value = _pv_opts_lookup(opts, key)
+          if value != nil
+            passes = false
+            [ to_be ].flatten.each do |tb|
+              if value == tb
+                passes = true
+              end
+            end
+            unless passes
+              raise ArgumentError, "Option #{key} must be equal to one of: #{to_be.join(", ")}!  You passed #{value.inspect}."
+            end
+          end
+        end
+        
+        # Raise an exception if the parameter is not a kind_of?(to_be)
+        def _pv_kind_of(opts, key, to_be)
+          value = _pv_opts_lookup(opts, key)
+          if value != nil
+            passes = false
+            [ to_be ].flatten.each do |tb|
+              if value.kind_of?(tb)
+                passes = true
+              end
+            end
+            unless passes
+              raise ArgumentError, "Option #{key} must be a kind of #{to_be}!  You passed #{value.inspect}."
+            end
+          end
+        end
+        
+        # Raise an exception if the parameter does not respond to a given set of methods.
+        def _pv_respond_to(opts, key, method_name_list)
+          value = _pv_opts_lookup(opts, key)
+          if value != nil
+            [ method_name_list ].flatten.each do |method_name|
+              unless value.respond_to?(method_name)
+                raise ArgumentError, "Option #{key} must have a #{method_name} method!"
+              end
+            end
+          end
+        end
+      
+        # Assign a default value to a parameter.
+        def _pv_default(opts, key, default_value)
+          value = _pv_opts_lookup(opts, key)
+          if value == nil
+            opts[key] = default_value
+          end
+        end
+        
+        # Check a parameter against a regular expression.
+        def _pv_regex(opts, key, regex)
+          value = _pv_opts_lookup(opts, key)
+          passes = false
+          [ regex ].flatten.each do |r|
+            if value != nil
+              if r.match(value.to_s)
+                passes = true
+              end
+            end
+          end
+          unless passes
+            raise ArgumentError, "Option #{key}'s value #{value} does not match regular expression #{regex.to_s}"
+          end
+        end
+        
+        # Check a parameter against a hash of proc's.
+        def _pv_callbacks(opts, key, callbacks)
+          raise ArgumentError, "Callback list must be a hash!" unless callbacks.kind_of?(Hash)
+          value = _pv_opts_lookup(opts, key)
+          if value != nil
+            callbacks.each do |message, zeproc|
+              if zeproc.call(value) != true
+                raise ArgumentError, "Option #{key}'s value #{value} #{message}!"
+              end
+            end
+          end
+        end
+    end
+  end
+end
+

data/readme.md

@@ -0,0 +1,83 @@
+# Hugo (Cloud DSL)
+<small>A simple dsl to deploy to the cloud</small>
+
+Currently only supports Amazon Web Services, but will be expanded soon!
+
+## Requirements
+
+First, you need a Amazon AWS Account
+
+You need to configure you system to contain AWS info in environment variables.
+
+Make sure you are enabled to generate ELB, RDS, and EC2.
+
+Make sure you have a keypair generated for you AWS Account!
+
+## What does it look like?
+
+    # mycloud.rb
+    require 'lib/hugo'
+
+    config = YAML.load_file("mycloud.yml")
+    
+    Hugo do
+      cloud "mycloud" do
+        balancer
+        
+        database "sample_app_production" do
+          server "company_server"
+          user "admin"
+          password "admin"
+        end
+        
+        app "sample_app" do
+          key_name "my-keypair"
+          
+          cookbook "git://github.com/twilson63/hugo-cookbooks.git"          
+          key_pair_file     "~/.ec2/my-keypair"
+          port              "8080"
+          github_url        "git@github.com:twilson63"
+          privatekey        config["github"]["privatekey"]
+          publickey         config["github"]["publickey"]
+          package_list      config["package_list"]
+          gem_list          config["gem_list"]
+          run_list          ["role[web-base]", "role[web-app]"]
+          
+          deploy_info :web_server_name => "sample_app.jackhq.com",
+              :restart_command => "gem bundle && touch tmp/restart.txt" 
+
+          servers 2
+          
+        end
+        
+        deploy
+        
+        print
+      end
+
+---
+
+## What about the config file?
+
+    # mycloud.yml
+    
+    github:
+      url: XXXX
+      publickey: XXX
+      privatekey: XXX
+
+    package_list:
+      - name: mysql-client
+      - name: libmysqlclient15-dev    
+      - name: libmysql-ruby1.8
+      - name: libexpat1
+      - name: libxml2
+      - name: libxml2-dev
+      - name: libxslt1-dev
+      - name: sqlite3
+      - name: libsqlite3-dev
+
+    gem_list:
+      - name: bundler
+    
+    

data/spec/lib/hugo/app_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Hugo App" do
+  before(:each) do
+    mocks
+  end
+  
+  it "should be valid" do
+    
+    block = lambda do
+      cloud "my_cloud" do 
+        balancer
+        app "testapp" do 
+          servers 0
+        end
+      end
+    end
+    
+    lambda do
+      Hugo &block
+    end.should_not raise_error
+  end
+
+  it "should raise error for database block not wrapped in cloud block" do
+    block = lambda do
+      app "myapp" do end
+    end
+    
+    lambda do
+      Hugo &block
+    end.should raise_error
+  end
+
+  it "should not raise error for database block wrapped in cloud block" do
+    block = lambda do
+      cloud "mycloud" do
+        app "myapp" do end
+      end
+    end
+    
+    lambda do
+      Hugo &block
+    end.should be_true
+  end
+end
+
+# describe Hugo::App do
+#   before(:each) do
+#     mocks
+#   end
+#   
+# 
+#   it "should create a new ec2 instance" do
+#     
+#     app = Hugo::App.instance
+#     app.key_name "ec2-keypair"
+# 
+#     app.servers 1
+#     app.name "mydb"
+#     #app.deploy.should be_a_kind_of(Hugo::Aws::Rds)
+#   end
+#   
+#   
+# end

data/spec/lib/hugo/aws/ec2_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Hugo::Aws::Ec2 do
+  before(:each) do
+    @mock = mock('AWS::EC2::Base')
+    instance = {"requestId"=>"e280b5aa-9b60-458f-b16f-96f97eb5e628", "reservationSet"=>
+      {"item"=>[{"reservationId"=>"r-ff5d8797", "groupSet"=>{"item"=>[{"groupId"=>"default"}]}, 
+                "instancesSet"=>{"item"=>[{"privateIpAddress"=>"10.210.43.6", "keyName"=>"ec2-keypair", "ramdiskId"=>"ari-0915f660", "productCodes"=>nil, "ipAddress"=>"174.129.63.98", "kernelId"=>"aki-5f15f636", "launchTime"=>"2009-11-29T13:20:48.000Z", "amiLaunchIndex"=>"0", 
+                "imageId"=>"ami-1515f67c", "instanceType"=>"m1.small", "reason"=>nil, "placement"=>{"availabilityZone"=>"us-east-1c"}, 
+                "instanceId"=>"i-12345678", "privateDnsName"=>"domU-XXXX.compute-1.internal", 
+                "dnsName"=>"ec2-XXX.compute-1.amazonaws.com", "monitoring"=>{"state"=>"enabled"}, 
+                "instanceState"=>{"name"=>"running", "code"=>"16"}}]}, "ownerId"=>"398217953086"}]}, "xmlns"=>"http://ec2.amazonaws.com/doc/2009-07-15/"}
+    
+    @mock.stub!(:run_instances).and_return(instance)
+    @mock.stub!(:describe_instances).and_return(instance)
+    @mock.stub!(:terminate_instances).and_return(instance)
+  
+    security_group = {"group_name"=>"test", "group_description"=>"test description"}
+    @mock.stub!(:create_security_groups).and_return(security_group)
+    @mock.stub!(:describe_security_groups).and_return(security_group)
+    @mock.stub!(:delete_security_group).and_return(security_group)
+  
+    AWS::EC2::Base.stub!(:new).and_return(@mock)
+  end
+        
+  # it "should create a new instance" do  
+  #   @ec2 = Hugo::Aws::Ec2.new()
+  #   @ec2.save.should be_true  
+  # end
+
+  it "should terminate instance" do
+    Hugo::Aws::Ec2.find('i-12345678').destroy.should be_true
+  end
+
+  it "should find instance" do
+    Hugo::Aws::Ec2.find('i-12345678').should_not be_nil
+  end
+
+  it "should return all instances" do
+    Hugo::Aws::Ec2.all.length.should == 1
+  end
+  
+  it "should find or create security group" do
+    Hugo::Aws::Ec2.find_or_create_security_group('test', 'test description').should_not be_empty
+  end
+  
+  it "should destroy a security group" do
+    Hugo::Aws::Ec2.destroy_security_group('test').should be_true
+  end
+  #
+  # it "should deploy app" do
+  #   
+  # end
+  # 
+end