dollhouse 0.1.2 → 0.2.0.beta.1

data/bin/dollhouse

@@ -6,45 +6,29 @@ require 'dollhouse'
 require 'main'
 
 Main do
-  mode 'deploy' do
-    argument('deployment') { required }
-    argument('prefix') { optional }
-    def run
-      Dollhouse.launch_from(Dir.pwd)
-      Dollhouse.initiate_deployment(params['deployment'].value.to_sym, :prefix => params['prefix'].value)
-    end
-  end
-
-  mode 'exec' do
-    argument('server_name') { required }
-    argument('cmd') { required }
-    def run
-      Dollhouse.launch_from(Dir.pwd)
-      Dollhouse.instances[params['server_name'].value].instance_eval params['cmd'].value
-    end
-  end
-
-  mode 'destroy' do
+  mode 'run' do
     argument('server_name') { required }
+    argument('task_name') { required }
     def run
       Dollhouse.launch_from(Dir.pwd)
-      Dollhouse.cloud_adapter.destroy params['server_name'].value
+      Dollhouse.run(params['server_name'].value, params['task_name'].value)
     end
   end
 
   mode 'list' do
     def run
       Dollhouse.launch_from(Dir.pwd)
-      p Dollhouse.cloud_adapter.list
+      puts Dollhouse.instances.list
     end
   end
 
-  mode 'run' do
+  # bit hax
+  mode 'exec' do
     argument('server_name') { required }
-    argument('task_name') { required }
+    argument('cmd') { required }
     def run
       Dollhouse.launch_from(Dir.pwd)
-      Dollhouse.instances[params['server_name'].value].run_task(params['task_name'].value)
+      Dollhouse.execute(params['server_name'].value, params['cmd'].value)
     end
   end
 

data/lib/dollhouse/config_loader.rb

@@ -18,22 +18,6 @@ module Dollhouse
   end
 
   class ServerBuilder < Struct.new(:name)
-    def instance_type t
-      @instance_type = t
-    end
-
-    def os o
-      @os = o
-    end
-
-    def from_latest_snapshot snapshot_name
-      @snapshot = snapshot_name
-    end
-
-    def first_boot &blk
-      callbacks[:first_boot] = blk
-    end
-
     def task name, &blk
       callbacks[name.to_s] = blk
     end

data/lib/dollhouse/deployment.rb

@@ -16,13 +16,6 @@ module Dollhouse
       end
     end
 
-    def server_online cloud_name, server
-      online_server = OnlineServer[cloud_name, self.name, server.name, :running]
-      Dollhouse.instances.server_came_online online_server
-      online_server.bootstrap
-      online_server.instance_eval &server.callbacks[:first_boot]
-    end
-
     def self.[](deployment)
       raise "Unknown deployment #{deployment}" unless all.has_key? deployment.to_s
       all[deployment.to_s]

data/lib/dollhouse/dollhouse.rb

@@ -1,18 +1,23 @@
 module Dollhouse
-  def self.launch_from(dir)
-    self.root = dir
-    # may need something cleverer in the future
-    require dir + '/config/dollhouse/config.rb'
-    Dir.glob(dir + '/config/dollhouse/auth.rb') { |f| require f } #optional require
-    Dir.glob(dir + '/config/dollhouse/deployments/*.rb') { |f| require f }
-  end
+  class << self
+    attr_accessor :root, :instances
 
-  def self.initiate_deployment(deployment, opts = {})
-    Deployment[deployment].initiate(opts)
-  end
+    def launch_from(dir)
+      self.root = dir
+      # may need something cleverer in the future
+      raise "You should be running this in your application root, or at least somewhere with a config/dollhouse subdirectory" if !File.exists?(File.join(dir, 'config', 'dollhouse'))
+      Dir.glob(dir + '/config/dollhouse/config.rb') { |f| require f } #optional require
+      Dir.glob(dir + '/config/dollhouse/auth.rb') { |f| require f } #optional require
+      Dir.glob(dir + '/config/dollhouse/deployments/*.rb') { |f| require f }
+    end
 
-  class << self
-    attr_accessor :root, :cloud_adapter, :instances
+    def run(server_name, task_name)
+      instances[server_name].run_task task_name
+    end
+
+    def execute(server_name, cmd)
+      instances[server_name].instance_eval cmd
+    end
 
     def instances
       @instances ||= Instances.new

data/lib/dollhouse/{online_server.rb → instance.rb}

@@ -1,35 +1,31 @@
 module Dollhouse
-  class OnlineServer < Struct.new(:name_in_cloud, :deployment_name, :server_name, :status, :ip)
+  class Instance < Struct.new(:instance_name, :deployment_name, :server_name, :ip)
     attr_accessor :user, :password
 
     def bootstrap
-      Dollhouse.cloud_adapter.execute(name_in_cloud, %Q{bash -c "`wget -O- babushka.me/up/hard`"}, default_opts)
+      cloud_adapter.execute(instance_name, %Q{bash -c "`wget -O- babushka.me/up/hard`"}, default_opts)
     end
 
     def babushka taskname, vars = {}
       # not used yet, but this makes sense. --defaults (or headless) is the default!
       if vars == :no_defaults
-        Dollhouse.cloud_adapter.execute(name_in_cloud, "babushka '#{taskname}'", default_opts)
+        cloud_adapter.execute(instance_name, "babushka '#{taskname}'", default_opts)
       else
         if !vars.empty?
           write_file(".babushka/vars/#{taskname}", {
             :vars => vars.map_keys(&:to_s).map_values { |v| {:value => v} }
           }.to_yaml)
         end
-        Dollhouse.cloud_adapter.execute(name_in_cloud, "babushka '#{taskname}' --defaults", default_opts)
+        cloud_adapter.execute(instance_name, "babushka '#{taskname}' --defaults", default_opts)
       end
     end
 
     def shell cmd, opts = {}
-      Dollhouse.cloud_adapter.execute(name_in_cloud, cmd, default_opts.merge(opts))
+      cloud_adapter.execute(instance_name, cmd, default_opts.merge(opts))
     end
 
     def write_file path, content, opts = {}
-      Dollhouse.cloud_adapter.write_file(name_in_cloud, path, content, default_opts.merge(opts))
-    end
-
-    def destroy
-      Dollhouse.cloud_adapter.destroy(name_in_cloud)
+      cloud_adapter.write_file(instance_name, path, content, default_opts.merge(opts))
     end
 
     def as user, opts = {}, &blk
@@ -42,10 +38,6 @@ module Dollhouse
       self.password = old_password
     end
 
-    def take_snapshot name
-      Dollhouse.cloud_adapter.take_snapshot(name_in_cloud, name + "-" + Time.now.strftime("%Y%M%d-%H%M%S"))
-    end
-
     def server
       deployment.servers.find { |s| s.name == server_name }
     end
@@ -58,6 +50,16 @@ module Dollhouse
       instance_eval &server.callbacks[task_name]
     end
 
+    def to_yaml
+      {instance_name => {'deployment_name' => deployment_name, 'server_name' => server_name, 'ip' => ip}}
+    end
+
+    def self.from_yaml(hash)
+      hash.map_values_with_keys { |k,v|
+        Instance[k, v['deployment_name'], v['server_name'], v['ip']]
+      }
+    end
+
     private
 
     def default_opts
@@ -66,5 +68,10 @@ module Dollhouse
       opts.merge!({:sudo_password => password}) if password
       opts
     end
+
+    # This could return different adapters, that connect to servers in different ways. For now we have a simple
+    def cloud_adapter
+      @cloud_adapter ||= ManualConfig.new
+    end
   end
 end

data/lib/dollhouse/instances.rb

@@ -15,12 +15,16 @@ module Dollhouse
 
     def online_servers
       @online_servers = if File.exists? "#{Dollhouse.root}/config/dollhouse/instances/servers.yml"
-        YAML::load_file("#{Dollhouse.root}/config/dollhouse/instances/servers.yml") or {}
+        Instance.from_yaml(YAML::load_file("#{Dollhouse.root}/config/dollhouse/instances/servers.yml") || {})
       else
         {}
       end
     end
 
+    def list
+      online_servers.inspect
+    end
+
     private
 
     def save!

data/lib/dollhouse/manual_config.rb

@@ -1,22 +1,13 @@
 module Dollhouse
-  class ManualConfig < CloudAdapter
+  class ManualConfig
     def execute(name, cmd, opts = {})
       #nasty, but sudo_password isn't valid for starting a connection
       sudo_password = opts.delete(:sudo_password)
       ssh_conn(Dollhouse.instances[name].ip, opts[:user] || 'root', opts) do
-        p "Executing: #{cmd}"
         exec cmd, {:sudo_password => sudo_password}
       end
     end
 
-    def boot_new_server(name, callback, opts)
-      raise "You can't, you fool!"
-    end
-
-    def list
-      Dollhouse.instances.online_servers.values.select { |i| i.status == :running }
-    end
-
     def write_file(name, path, content, opts)
       ssh_conn(Dollhouse.instances[name].ip, opts[:user] || 'root', opts) do
         write_file(path) do |out|

data/lib/dollhouse/remote_server.rb

@@ -1,4 +1,4 @@
-# Let it be known, dgoodlad is a profase.
+# Let it be known, @dgoodlad is a profase.
 
 require 'net/ssh'
 require 'net/sftp'
@@ -48,7 +48,7 @@ module Dollhouse
           output = ''
           status_code = nil
 
-          puts "Executing:\n#{command}"
+          puts "## Executing: #{command}"
 
           ch.exec(command) do |ch, success|
             raise "Failed to start execution!" unless success

data/lib/dollhouse/version.rb

@@ -1,3 +1,3 @@
 module Dollhouse
-  VERSION = "0.1.2" unless defined?(Dollhouse::VERSION)
+  VERSION = "0.2.0.beta.1" unless defined?(Dollhouse::VERSION)
 end

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: dollhouse
 version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: false
+  hash: 62196353
+  prerelease: true
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  - beta
+  - 1
+  version: 0.2.0.beta.1
 platform: ruby
 authors: 
 - Glen Maddern
@@ -15,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-08 00:00:00 +11:00
+date: 2010-11-12 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -98,26 +100,10 @@ dependencies:
         version: 0.10.3
   type: :runtime
   version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: bundler
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 17
-        segments: 
-        - 1
-        - 0
-        - 3
-        version: 1.0.3
-  type: :development
-  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: cucumber
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -129,11 +115,11 @@ dependencies:
         - 3
         version: 0.9.3
   type: :development
-  version_requirements: *id007
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -145,11 +131,11 @@ dependencies:
         - 7
         version: 0.8.7
   type: :development
-  version_requirements: *id008
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -161,7 +147,7 @@ dependencies:
         - 0
         version: 2.0.0
   type: :development
-  version_requirements: *id009
+  version_requirements: *id008
 description: Dollhouse is a way to deploy servers. It is designed to be used with Babushka.
 email: glen.maddern@gmail.com
 executables: 
@@ -173,14 +159,12 @@ extra_rdoc_files: []
 files: 
 - bin/dollhouse
 - lib/core_ext/hash.rb
-- lib/dollhouse/cloud_adapter.rb
 - lib/dollhouse/config_loader.rb
 - lib/dollhouse/deployment.rb
 - lib/dollhouse/dollhouse.rb
+- lib/dollhouse/instance.rb
 - lib/dollhouse/instances.rb
 - lib/dollhouse/manual_config.rb
-- lib/dollhouse/online_server.rb
-- lib/dollhouse/rackspace_cloud_adapter.rb
 - lib/dollhouse/remote_server.rb
 - lib/dollhouse/server.rb
 - lib/dollhouse/version.rb

data/lib/dollhouse/cloud_adapter.rb

@@ -1,21 +0,0 @@
-module Dollhouse
-  class CloudAdapter
-    def initialize
-      raise NotImplementedError, %Q{
-      Must implement the following methods:
-
-      boot_new_server(name, callback, opts)
-      - name is the unique id for the server in this cloud
-      - callback is a lambda to be fired_off when that server comes online
-      - generally, opts has :machine_id, :ram_size, :data_center, :backup_image_id
-
-      execute(server_name, cmd, opts)
-
-      write_file(server_name, path, content, opts)
-
-      list
-
-    } unless [:boot_new_server, :execute, :write_file, :list].all? { |m| self.class.method_defined? m }
-    end
-  end
-end

data/lib/dollhouse/rackspace_cloud_adapter.rb

@@ -1,101 +0,0 @@
-module Dollhouse
-  class RackspaceCloudAdapter < CloudAdapter
-    FLAVORS = {"256mb" => 1, "512mb" => 2, "1024mb" => 3, "2048mb" => 4}
-    IMAGES = {"Ubuntu 10.04" => 49}
-
-    def conn
-      require 'fog'
-      @conn ||= Fog::Rackspace::Servers.new(
-                  :rackspace_api_key => Auth::Rackspace::API_KEY,
-                  :rackspace_username => Auth::Rackspace::USERNAME
-      )
-    end
-
-    def boot_new_server(name, callback, opts)
-      flavor_num = FLAVORS[opts[:instance_type]]
-      raise "Unknown instance_type of #{opts[:instance_type].inspect}. Permitted values are #{FLAVORS.keys.inspect}" unless flavor_num
-      image_num = if opts[:snapshot]
-        image = conn.images.select { |i| i.created_at && i.name =~ Regexp.new(Regexp.escape(opts[:snapshot])) }.sort_by { |i| i.created_at }.last
-        raise "Snapshot name of #{opts[:snapshot]} doesn't match any images!" unless image
-        puts "Booting from image: #{image.inspect}"
-        image.id
-      else
-        raise "Unknown os of #{opts[:os].inspect}. Permitted values are #{IMAGES.keys.inspect}" unless IMAGES[opts[:os]]
-        IMAGES[opts[:os]]
-      end
-
-      puts "Booting server #{name}"
-      server = conn.servers.create(:flavor_id => flavor_num, :image_id => image_num, :name => name)
-
-      puts "Server booted: #{server.inspect}"
-      # make this asynch soon
-      server.wait_for { ready? }
-      puts "Server #{name} online. Adding our private key"
-      server.public_key_path = Auth::KEYPAIR + ".pub"
-      server.setup
-      puts "Done. Ready to go!"
-
-      callback.call
-    end
-
-    def execute(name, cmd, opts = {})
-      #nasty, but sudo_password isn't valid for starting a connection
-      sudo_password = opts.delete(:sudo_password)
-      ssh_conn(name, opts) do
-        p "Executing: #{cmd}"
-        exec cmd, {:sudo_password => sudo_password}
-      end
-    end
-
-    def write_file(name, path, content, opts = {})
-      ssh_conn(name, opts) do
-        write_file(path) do |out|
-          out.puts content
-        end
-      end
-    end
-
-    def destroy name
-      server = get_server name
-      puts "Killing server #{server.inspect}"
-      server.destroy
-      puts "Done."
-    end
-
-    def take_snapshot name, snapshot_name
-      response = conn.create_image get_server(name).id, 'name' => snapshot_name
-      puts "Created image: #{response.body['image'].inspect}"
-    end
-
-    def list
-      conn.servers
-    end
-
-    private
-
-    def ssh_conn(name, opts, &blk)
-      #nasty, but sudo_password isn't valid for starting a connection
-      opts.delete(:sudo_password)
-      ssh_conns[[name, opts]].instance_eval(&blk)
-    end
-
-    def ssh_conns
-      @ssh_conns ||= Hash.new { |h, (name, opts)|
-        puts "Establishing connection to #{name}:"
-        #change this to use instances.yml, or something
-        server = get_server name
-        host = server.addresses['public'].first
-        user = opts[:user] || 'root'
-        puts "Connecting to #{host} as #{user}..."
-
-        h[[name, opts]] = RemoteServer.new(host, user, {:forward_agent => true}.merge(opts))
-      }
-    end
-
-    def get_server name
-      server = conn.servers.find { |s| s.name == name }
-      raise "Can't find server #{name}" if server.nil?
-      server
-    end
-  end
-end