dollhouse 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Glen Maddern
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# Dollhouse
+
+Dollhouse is a way to deploy servers.

data/bin/dollhouse

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
+
+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
+    argument('server_name') { required }
+    def run
+      Dollhouse.launch_from(Dir.pwd)
+      Dollhouse.cloud_adapter.destroy params['server_name'].value
+    end
+  end
+
+  mode 'list' do
+    def run
+      Dollhouse.launch_from(Dir.pwd)
+      p Dollhouse.cloud_adapter.list
+    end
+  end
+
+  mode 'run' do
+    argument('server_name') { required }
+    argument('task_name') { required }
+    def run
+      Dollhouse.launch_from(Dir.pwd)
+      Dollhouse.instances[params['server_name'].value].run_task(params['task_name'].value)
+    end
+  end
+
+  # Print the useage message by default.
+  def run
+    help!
+  end
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  def map_keys &blk
+    map_keys_with_values { |k, v| blk.call(k) }
+  end
+
+  def map_keys_with_values &blk
+    result = {}
+    each { |k, v| result[blk.call(k, v)] = v }
+    result
+  end
+
+  def map_values &blk
+    map_values_with_keys { |k, v| blk.call(v) }
+  end
+
+  def map_values_with_keys &blk
+    result = {}
+    each { |k, v| result[k] = blk.call(k, v) }
+    result
+  end
+end

data/lib/dollhouse/cloud_adapter.rb

@@ -0,0 +1,21 @@
+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/config_loader.rb

@@ -0,0 +1,49 @@
+def deployment name, &blk
+  Dollhouse::Deployment.register(Dollhouse::DeployBuilder[name].tap { |d| d.instance_eval(&blk) }.to_deployment)
+end
+
+module Dollhouse
+  class DeployBuilder < Struct.new(:name)
+    def to_deployment
+      Deployment.new(name, servers.map(&:to_server))
+    end
+
+    def server server_name, &blk
+      servers << ServerBuilder[server_name].tap { |s| s.instance_eval(&blk) }
+    end
+
+    def servers
+      @servers ||= []
+    end
+  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
+
+    def to_server
+      Server[name, @instance_type, @os, @snapshot, callbacks]
+    end
+
+    def callbacks
+      @callbacks ||= {}
+    end
+  end
+end

data/lib/dollhouse/deployment.rb

@@ -0,0 +1,39 @@
+module Dollhouse
+  class Deployment
+    attr_accessor :name, :servers
+
+    def initialize name, servers
+      @name = name
+      @servers = servers
+    end
+
+    def initiate opts
+      servers.each do |server|
+        cloud_name = [opts[:prefix], server.name].compact.join("-")
+        Dollhouse.cloud_adapter.boot_new_server cloud_name,
+                                                lambda { server_online(cloud_name, server) },
+                                                {:instance_type => server.instance_type, :os => server.os, :snapshot => server.snapshot}
+      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]
+    end
+
+    def self.register deployment
+      all.merge! deployment.name.to_s => deployment
+    end
+
+    def self.all
+      @all ||= {}
+    end
+  end
+end

data/lib/dollhouse/dollhouse.rb

@@ -0,0 +1,21 @@
+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
+
+  def self.initiate_deployment(deployment, opts = {})
+    Deployment[deployment].initiate(opts)
+  end
+
+  class << self
+    attr_accessor :root, :cloud_adapter, :instances
+
+    def instances
+      @instances ||= Instances.new
+    end
+  end
+end

data/lib/dollhouse/instances.rb

@@ -0,0 +1,33 @@
+module Dollhouse
+  class Instances
+    def initialize
+      require 'yaml'
+    end
+
+    def server_came_online online_server
+      online_servers[online_server.name_in_cloud] = online_server
+      save!
+    end
+
+    def [] name
+      online_servers[name] or raise "Don't have any record of a server called #{name.inspect}!"
+    end
+
+    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 {}
+      else
+        {}
+      end
+    end
+
+    private
+
+    def save!
+      FileUtils.mkdir_p(Dollhouse.root + '/config/dollhouse/instances')
+      File.open(Dollhouse.root + '/config/dollhouse/instances/servers.yml', 'w') { |f|
+        YAML::dump(@online_servers, f)
+      }
+    end
+  end
+end

data/lib/dollhouse/manual_config.rb

@@ -0,0 +1,42 @@
+module Dollhouse
+  class ManualConfig < CloudAdapter
+    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|
+          out.puts content
+        end
+      end
+    end
+
+    private
+
+    def ssh_conn(host, user, opts, &blk)
+      #nasty, but sudo_password isn't valid for starting a connection
+      opts.delete(:sudo_password)
+      ssh_conns[[host, user, opts]].instance_eval(&blk)
+    end
+
+    def ssh_conns
+      @ssh_conns ||= Hash.new { |h, (host, user, opts)|
+        h[[host, user, opts]] = RemoteServer.new(host, user, {:forward_agent => true}.merge(opts))
+      }
+    end
+  end
+end

data/lib/dollhouse/online_server.rb

@@ -0,0 +1,70 @@
+module Dollhouse
+  class OnlineServer < Struct.new(:name_in_cloud, :deployment_name, :server_name, :status, :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)
+    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)
+      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)
+      end
+    end
+
+    def shell cmd, opts = {}
+      Dollhouse.cloud_adapter.execute(name_in_cloud, 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)
+    end
+
+    def as user, opts = {}, &blk
+      old_user = self.user
+      old_password = self.password
+      self.user = user
+      self.password = opts[:password]
+      instance_eval(&blk)
+      self.user = old_user
+      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
+
+    def deployment
+      Deployment[self.deployment_name]
+    end
+
+    def run_task task_name
+      instance_eval &server.callbacks[task_name]
+    end
+
+    private
+
+    def default_opts
+      opts = {}
+      opts.merge!({:user => user}) if user
+      opts.merge!({:sudo_password => password}) if password
+      opts
+    end
+  end
+end

data/lib/dollhouse/rackspace_cloud_adapter.rb

@@ -0,0 +1,101 @@
+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

data/lib/dollhouse/remote_server.rb

@@ -0,0 +1,101 @@
+# Let it be known, dgoodlad is a profase.
+
+require 'net/ssh'
+require 'net/sftp'
+require 'tempfile'
+
+module Dollhouse
+  class RemoteServer
+    class FailedRemoteCommand < Exception;
+    end
+
+    include Net::SSH::Prompt
+
+    attr_reader :ssh, :host, :user, :init_opts
+
+    def initialize(host, user, opts = {})
+      begin
+        @ssh = Net::SSH.start(host, user, opts)
+      rescue Net::SSH::HostKeyMismatch => exception
+        exception.remember_host!
+        sleep 0.2
+        retry
+      end
+
+      @host = host
+      @user = user
+      @init_opts = opts
+    end
+
+    # Write to a remote file at _path_.
+    def write_file(path)
+      exec "mkdir -p #{File.dirname(path).gsub(/ /, "\\ ")}"
+      Tempfile.open(File.basename(path)) do |f|
+        yield f
+        f.flush
+        remote_path = %Q{"#{@user}@#{host}:#{path.gsub(/ /, "\\ ")}"}
+        puts "Writing to #{remote_path}"
+        `scp '#{f.path}' #{remote_path}`
+      end
+    end
+
+    def exec(command, opts = {})
+      channel = @ssh.open_channel do |ch|
+        ch.request_pty(:term => 'xterm-color') do |ch, success|
+          raise "Failed to get a PTY!" unless success
+
+          output = ''
+          status_code = nil
+
+          puts "Executing:\n#{command}"
+
+          ch.exec(command) do |ch, success|
+            raise "Failed to start execution!" unless success
+
+            ch.on_data do |ch, data|
+                         # could loop badly
+              if opts[:sudo_password] && data =~ /\[sudo\] password for/
+                print data
+                puts "*SUDO PASSWORD AUTOMATICALLY SENT*"
+                ch.send_data("#{opts[:sudo_password]}\n")
+              elsif data =~ /[Pp]assword.+:/
+                ch.send_data("#{prompt(data, false)}\n")
+              elsif data =~ /continue connecting \(yes\/no\)\?/
+                ch.send_data("#{prompt(data, true)}\n")
+              else
+                print data
+              end
+
+              output << data
+            end
+
+            ch.on_extended_data do |ch, data|
+              print data
+            end
+
+            ch.on_request('exit-status') do |ch, data|
+              status_code = data.read_long
+            end
+          end
+          ch.wait
+
+          unless status_code.zero?
+            raise FailedRemoteCommand, "Status code: #{status_code}"
+          end
+
+          result = [status_code.zero?, output, status_code]
+          block_given? ? yield(result) : result
+        end
+      end
+      channel.wait
+    end
+
+    def get_environment(var)
+      @ssh.exec!("echo $#{var}").strip
+    end
+
+    def connected_as_root?
+      @ssh.exec!("id") =~ /^uid=0\(root\)/
+    end
+  end
+end

data/lib/dollhouse/server.rb

@@ -0,0 +1,4 @@
+module Dollhouse
+  class Server < Struct.new(:name, :instance_type, :os, :snapshot, :callbacks)
+  end
+end

data/lib/dollhouse/version.rb

@@ -0,0 +1,3 @@
+module Dollhouse
+  VERSION = "0.1.1" unless defined?(Dollhouse::VERSION)
+end

data/lib/dollhouse.rb

@@ -0,0 +1,5 @@
+module Dollhouse
+end
+
+Dir.glob(File.dirname(__FILE__) + '/core_ext/*.rb') { |f| require f }
+Dir.glob(File.dirname(__FILE__) + '/dollhouse/*.rb') { |f| require f }

metadata

@@ -0,0 +1,227 @@
+--- !ruby/object:Gem::Specification 
+name: dollhouse
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Glen Maddern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-28 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: main
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 4
+        - 2
+        - 0
+        version: 4.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: fog
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 2
+        - 30
+        version: 0.2.30
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 33
+        segments: 
+        - 2
+        - 0
+        - 23
+        version: 2.0.23
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: net-sftp
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 10
+        - 3
+        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 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 9
+        - 3
+        version: 0.9.3
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id009
+description: Dollhouse is a way to deploy servers. It is designed to be used with Babushka.
+email: glen.maddern@gmail.com
+executables: 
+- dollhouse
+extensions: []
+
+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/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
+- lib/dollhouse.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/geelen/dollhouse
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: dollhouse
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A place to manage your babushkas.
+test_files: []
+