cloudspeq 0.0.15

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54e96a5a8ca4132e21346042feffd9eb8682ea48
+  data.tar.gz: d64a3fcea08a178fb9ff76f162d347c8b6cdcc67
+SHA512:
+  metadata.gz: 6612dbce34c281ff7cd1737b9f4e0d66723e52aff60acb0ca91f0a35c43825fbd1db4a842811f7d7de41b527efccc6c5cea5bb05f0e903a5541de928947d1eff
+  data.tar.gz: 1be896879bb52b6361ddeadd237cbd260e25c38cebaec59771f1d550897fad11c8618354a962a430092d46e10498ac8603a14ed808675dd075b7ec827849d278

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cloudspeq.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Russell Jennings
+
+MIT License
+
+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,229 @@
+# Cloudspeq (Beta)
+
+Cloudspeq distributes your specs across machines in the cloud to dramatically reduce the time it takes to test. 
+
+## Introduction
+
+Fast specs are ideal in development, but are often not possible for an app due to cost or effort required, or simply because there are a lot of slow things to test. What is a developer to do, sit around while the tests run? Some test suits can take half an hour! 
+
+To address this, cloudspeq throws computing power at it.
+
+### Benefits
+
+ - Plug and play: works with any rails codebase without app configuration
+ - Fast: Can make a 5 minute test suit run in 20 seconds
+ - Scalable: Can work with 10 machines, or 100. 
+ - Controlable: You control what kind of machines to use, how many, and for how long. You also control which provider to use (so long as its digital ocean)
+ - Load Balanced: specs are parsed for definitions and randomly distributed across machines to reduce testing hotspots
+ - Princesses: Some directories / files / specs need special attention. Set aside machines to focus specifically on them
+ - Safe: Ignores other machines on the provider that do not relate to testing
+ - More Safe: Machines can self-destruct to ensure you dont get charged for machines you're not using
+
+Right now, only Digital Ocean is supported as a provider, but others providers are possible in the future. 
+
+Written to work with Rspec, but other test frameworks should more or less work too. 
+
+### Cloudspeq Vs. CI
+
+Cloudspeq was built to make testing in dev faster by working with the code you haven't commited to your repositiory. This is different from the role of CI, which is to test commited code, and where the test time is not as noticeable. This isn't to say Cloudspeq can't serve a CI role, only that it was not an orignal design intention. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cloudspeq'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cloudspeq
+
+
+To install the require config file, execute:
+
+```
+cloudspeq install
+```
+
+The `cloudspeq.yml` file contains all the defaults that cloudspeq uses. You'll need to fill in the neccesary provider information. Everything but the provider info can be removed if you want to rely on the defaults; or you can customize them to suit your needs. 
+
+## Preperation
+
+You'll need a machine that can run your tests. This can be achieved by either:
+  
+  1. Creating a machine image
+  2. Preparing the machine after boot
+
+It is highly recommend you create a machine image to reduce the time it takes to prepare for testing. 
+
+Things you'll need to do:
+  1. Ensure user & project directory exist as defined in `cloudspeq.yml`
+  2. Sync local directory to remote project directory (you can run `cloudspeq machines sync`). configure `sync_excludes` in the config file to skip any directories not needed for test; it already skips `.git/` and `tmp/`.
+  3. Ensure test suite runs on remote machine
+  4. Install ssh keys for root & user on remote machine
+  5. Optionally, you can have the machines self-destruct after a certain ammount of uptime. This is a great way to ensure machines don't accidently linger for longer than they need to, in case you forget to delete the machines after testing. It also means if you want more time, you can just reboot. For this to work it requires cloudspeq be installed on the machine, and that it have access to the `cloudspeq.yml` file. Then you just need to define a cron entry for it. For example:
+
+  ```
+  */2 * * * * cd /home/tester/project/; /usr/local/bin/cloudspeq self_destruct
+  ```
+
+  Adjust to match your enviroment, and be sure to test it works in cron before relying on it. By default, the `server_lifetime` is 90 (minutes), but you can change this in the `cloudspeq.yml` file, or specify the number of minutes by passing it as a parameter to the `self_destruct` command. 
+  6. Shutdown the machine, and create a snapshot
+  7. In `cloudspeq.yml`, specify `image_name` using the name of the snapshot you just created under the provider
+
+
+
+## Usage
+
+
+### Create some machines to test with
+
+ ```
+ cloudspeq machines create
+ ```
+
+ This creates the number of machines specified in the provder machine_count. You can run this command multiple times to create machines in multiples, or provide the number to create as a parameter to the command. 
+
+
+### Check the status of the machines
+
+Creating machines can take a few minutes, especially if you create a lot. Run the status command to see how things are coming along
+
+```
+cloudspeq machines status
+```
+
+### Prepare SSH (recommended)
+
+SSH-ing into the machines modifies `~/.ssh/known_hosts` but these entries can lead to warnings later if we create another machine with the same IP and a different public_key. So, this will backup the file for later restoration. 
+
+```
+cloudspeq ssh backup
+```
+
+### Sync 
+
+Sync the project files to the machines
+
+```
+cloudspeq sync
+```
+
+### Prepare for testing
+
+Executes all `remote_prepare` commands defined in the config file. Useful for starting up services, migrations, or what have you. 
+
+```
+cloudspeq machines prepare
+```
+
+### Run tests
+
+Run the tests and get a report of the results. 
+
+```
+cloudspeq run
+```
+
+### Destroy
+
+After testing, destroy the machines
+
+```
+cloudspeq machines destroy
+```
+
+This destroys the same number of machines defined in `machine_count`. You can also pass this command a number to specify how many machines to destroy. 
+
+The above only pulls from the local machines file, and might not destroy all the machines. To destroy all machines on the provider that are test related:
+
+```
+cloudspeq machines destroy_all
+```
+
+Machines not related to testing, such as production machines, are ignored. 
+
+### Restore SSH
+
+```
+cloudspeq ssh restore
+```
+
+### Additional Usage
+
+ - You can use the `machines execute` and `machines root_execute` to execute commands across the machines
+ - To run commands locally for prepare: `cloudspeq prepare` and for cleanup: `cloudspeq clean_up`
+
+Most commands have a short-hand that is a few letters long. See `cloudspeq -h` for more info, or `cloudspeq command -h` for specific command related help. 
+
+## Optimizations
+
+While cloudspeq can dramtically speed things up out of the box, with some tuning you can get things running even faster. 
+
+### Princesses
+
+While Cloudspeq load-balancing can reduce hotspots, Some specs need to be pampered to get the most out of them. These can be directories, files, or specific specs. 
+
+By defining a princess, you can dedicate machines to focus on something in particular, in order to reduce the overall time it takes for the test suite to execute. it can take some tinkering to identify an ideal configuation for your particular app. 
+
+By default, all specs are distributed and run under a default princess "misc", where misc has a machine pool equal to the number of machines defined. When you define a princess, machines are set aside from those available, and the specs that are sent to them are removed from misc. The 'misc' group is the catch-all, and you'll get an error if there is not at least 1 machine available for it.
+
+The order matters, so its best to be specific at the top and general at the bottom. 
+
+an example princesses definition looks like:
+
+```
+princesses:
+  "controllers/search_controller_spec.rb":  {servers: 2, symbol: 'G'}
+  "controllers/store":                      {servers: 4, symbol: "S", threads: 2}
+  "acceptance":                             {servers: 2, symbol: 'A', per: 1}
+  "models":                                 {servers: 3, symbol: 'M', load_balance: false}
+```
+
+Each princess consists of:
+   
+  1. a directory, file, or line number to test; as the key
+  2. a hash value containing
+    1. `servers` is to specify the number of machines to dedicate
+    2. `symbol` is the symbol to use in output when representing (optional - defaults to '.')
+    3. `load_balance` is to control if spec files should be broken up or fed in whole; useful if a spec file has expensive setup, but otherwise load_balancing is faster.
+    4. `threads` controls the number of SSH connections to make to each machine, by default just 1. Useful if your tests can run in paralell without interfering with each other in the database, and you want to drive the machine harder.
+    5. `per` defines how many specs each thread should receive. by default it is number of specs / number of threads, but if you specify a lower number it will cause machines to come back after finishing and be available for additional specs to work on, instead of sitting idle after they've finished. 
+
+If you define a 'misc' princess (with 'misc' as the key) as the last definition, you can adjust these parameters as they apply to any specs that fall in the misc group. This is also useful if you want to experiment with how long the specs take to run with a given number of machines. 
+
+### Spec Tuning
+
+To optimize your tests to run with cloudspeq, they should be fast. Load-balancing and Princesses can help a lot, but in the end you'll only be able to be as fast as your slowest spec. If you have a spec that checks 6 different things and takes 6 seconds to run, you can optimize it by breaking it up into different specs, so that load-balancing can distribute the load across multiple machines.
+
+## Roadmap
+
+Cloudspeq is just getting started! Coming eventually:
+
+- More providers (EC2, linode, raspberry-pi)
+- Test coverage
+- Better test profiling display
+- Machine profiling
+- Machine profiling test correlation
+- Automatic tuning & optimizing
+- Framework Atheism
+- Distributed Rails Load Testing
+
+Want to help realize one of these ideas, or have an idea of your own? Submit a PR! 
+
+## Contributing
+
+1. Fork it ( https://github.com/meesterdude/cloudspeq/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/cloudspeq

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'escort'
+require 'cloudspeq'
+
+Escort::App.create do |app|
+  app.summary "Run your rails tests in the cloud for faster exectuion"
+
+
+  app.options do |opts|
+    opts.opt :provider, "provider to use", :short => '-p', :long => '--provider', :type => :string, default: 'digitalocean'
+    opts.opt :cfg, "config file path", :short => '-c', :long => '--config', :type => :string, default: 'cloudspeq.yml'
+  end
+
+  
+  app.command :install, aliases: [:i] do |command|
+    command.summary "Install config file"
+    command.action do |options, arguments|
+      Cloudspeq.install
+    end
+    
+  end
+  
+
+  app.command :machines, aliases: [:m] do |command|
+    command.summary "Wrapper for commands to create and manage machines"
+
+
+    command.command :create,  aliases: [:c] do |cmd|
+      cmd.summary "create machines to use for testing"
+      cmd.description "Optionally takes a number of machines to create"
+      cmd.action do |options, arguments|
+        c = Cloudspeq.new(options[:global][:options][:cfg])
+        !arguments.empty? ? c.spool_up(arguments.first) : c.spool_up
+      end
+    end
+
+    command.command :status, aliases: [:s] do |cmd|
+      cmd.summary "statuses of machines"
+      cmd.action do |options, arguments|
+        c = Cloudspeq.new(options[:global][:options][:cfg])
+        pp c.status
+      end
+    end
+
+    command.command :destroy, aliases: [:d] do |cmd|
+      cmd.summary "destroy machines used for testing defined in local file"
+      cmd.description "Optionally takes a number of machines to destroy"
+       cmd.action do |options, arguments|
+         c = Cloudspeq.new(options[:global][:options][:cfg])
+         !arguments.empty? ? c.spool_down(arguments.first) : c.spool_down
+      end
+    end
+
+    command.command :destroy_all, aliases: [:da] do |cmd|
+      cmd.summary "destroy all machines on remote that are used for testing"
+      cmd.action do |options, arguments|
+         c = Cloudspeq.new(options[:global][:options][:cfg])
+         c.spool_down_all
+      end
+    end
+
+    command.command :prepare, aliases: [:p] do |cmd|
+      cmd.summary "Run remote_prepare commands defined in config file across remote machines"
+      cmd.action do |options, arguments|
+        c = Cloudspeq.new(options[:global][:options][:cfg])
+        c.remote_prepare
+      end
+    end
+
+    command.command :clean_up, aliases: [:cu] do |cmd|
+      cmd.summary "Run remote_clean_up commands defined in config file across remote machines"
+      cmd.action do |options, arguments|
+        c = Cloudspeq.new(options[:global][:options][:cfg])
+        pp c.remote_clean_up
+      end
+    end
+
+    command.command :sync, aliases: [:sy] do |cmd|
+      cmd.summary "sync current directory with machines"
+      cmd.action do |options, arguments|
+        c = Cloudspeq.new(options[:global][:options][:cfg])
+        c.sync
+      end
+    end
+
+    command.command :execute, aliases: [:x] do |cmd|
+      cmd.summary "Execute a command across all machines"
+      cmd.description "Takes an argument as a command to execute"
+      cmd.action do |options, arguments|
+        c = Cloudspeq.new(options[:global][:options][:cfg])
+        result = c.execute arguments.first
+        result.each do |k,v|
+          puts "\n#{k}: #{v}"
+        end
+      end
+    end
+
+    command.command :root_execute, aliases: [:rx] do |cmd|
+      cmd.summary "Execute a command across all machines as root"
+      cmd.description "Takes an argument as a command to execute"
+      cmd.action do |options, arguments|
+        c = Cloudspeq.new(options[:global][:options][:cfg])
+        result = c.root_execute arguments.first
+        result.each do |k,v|
+          puts "\n#{k}: #{v}"
+        end
+      end
+    end
+
+  end
+
+  app.command :ssh do |command|
+    command.summary "Wrapper for commands to backup, restore and reset the ssh known_hosts file"
+    command.command :backup, aliases: [:bu] do |cmd|
+      cmd.summary "backup the known_hosts file"
+      cmd.action do |options, arguments|
+        Cloudspeq.backup_ssh
+      end
+    end
+    command.command :restore, aliases: [:rso] do |cmd|
+      cmd.summary "restore the known_hosts file, removing backup"
+      cmd.action do |options, arguments|
+        Cloudspeq.restore_ssh
+      end
+    end
+    command.command :reset, aliases: [:rse] do |cmd|
+      cmd.summary "restore the known_hosts file, keeping backup"
+      cmd.action do |options, arguments|
+        Cloudspeq.reset_ssh
+      end
+    end
+  end
+
+  app.command :self_destruct do |command|
+    command.summary "run on the server to destroy after X uptime in minutes (default 90 minutes)"
+    command.description "Optional argument is minutes of uptime to destroy after, uses server_lifetime config option otherwise"
+    command.action do |options, arguments|
+      c = Cloudspeq.new(options[:global][:options][:cfg])
+      minutes = !arguments.empty? ? arguments.first.to_f : c.settings['server_lifetime'].to_f
+      uptime = `cat /proc/uptime`.split(" ").first.to_f / 60
+      if uptime > minutes
+        name = `hostname`.strip
+        puts "*** Destroying this machine"
+        machine = c.provider.machines.find{|m| m.name == name}
+        machine.destroy if machine 
+      else
+        puts "not ready for self destruct"
+      end
+    end
+  end
+
+  app.command :prepare, aliases: [:p] do |command|
+    command.summary "Locally run commands defined in local_prepare"
+    command.action do |options, arguments|
+      c = Cloudspeq.new(options[:global][:options][:cfg])
+      c.local_prepare
+    end
+  end
+
+  app.command :clean_up, aliases: [:cu] do |command|
+    command.summary "Locally run commands defined in local_clean_up"
+    command.action do |options, arguments|
+      c = Cloudspeq.new(options[:global][:options][:cfg])
+      c.local_clean_up
+    end
+  end
+
+  app.command :run, aliases: [:r] do |command|
+    command.summary "Distribute the tests and display the results"
+    command.action do |options, arguments|
+      c = Cloudspeq.new(options[:global][:options][:cfg])
+      Cloudspeq::RspecOutputter.perform c.run_tests
+    end
+  end
+
+end

data/cloudspeq.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cloudspeq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cloudspeq"
+  spec.version       = Cloudspeq::VERSION
+  spec.authors       = ["Russell Jennings"]
+  spec.email         = ["violentpurr@gmail.com"]
+  spec.summary       = %q{Distribute your tests in the cloud for faster development in slow test suits}
+  spec.description   = %q{Having a slow test suite sucks. But don't let a slow test suite slow you down! with cloudspeq you can distribute your tests and dramatically reduce the time it takes to test.}
+  spec.homepage      = "https://github.com/meesterdude/cloudspeq"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'escort', "~> 0.4"
+  spec.add_dependency 'digitalocean', "~> 1.2"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.executables << 'cloudspeq'
+end

data/lib/cloudspeq.rb

@@ -0,0 +1,122 @@
+require 'ostruct'
+require 'yaml'
+require 'benchmark'
+require 'digitalocean'
+require_relative "cloudspeq/version"
+require_relative "cloudspeq/providers/base"
+require_relative "cloudspeq/providers/digital_ocean"
+require_relative "cloudspeq/defaults"
+require_relative "cloudspeq/distributed_testing"
+require_relative "cloudspeq/rspec_outputter"
+
+class Cloudspeq
+  # this is the public API. 
+
+  def initialize(settings_path= 'cloudspeq.yml')
+    @settings = Cloudspeq.settings(settings_path)
+    provider_key = @settings['provider_key']
+    provider = Object.const_get "Cloudspeq::Providers::" + provider_key.to_s.split("_").collect(&:capitalize).join
+    
+    @provider = provider.new(@settings)
+  end
+
+  def self.install
+    File.open('cloudspeq.yml',"w") do |f|
+      f.write(DEFAULT_SETTINGS.to_yaml)
+    end
+  end
+
+  def self.settings(path=nil)
+    @settings ||= OpenStruct.new DEFAULT_SETTINGS.merge( YAML.load_file(path) )
+  end
+
+  def settings
+    @settings
+  end
+
+  def status
+    refresh
+    provider.status
+  end
+
+  def provider
+    @provider
+  end
+
+  def spool_up(n=provider.provider_settings['machine_count'])
+    provider.create n
+  end
+
+  def remote_prepare
+    output = []
+    @settings['remote_prepare'].each do |command|
+     output << provider.exec(command)
+    end
+    output
+  end
+
+  def remote_clean_up
+    @settings['remote_cleanup'].each do |command|
+      provider.exec(command)
+    end
+  end
+
+  def local_prepare
+    output = []
+    @settings['local_prepare'].each do |command|
+     `#{command}`
+    end
+  end
+
+  def local_clean_up
+    @settings['local_clean_up'].each do |command|
+      `#{command}`
+    end
+  end
+
+  def spool_down(n=provider.provider_settings['machine_count'])
+    provider.destroy provider.machines.first(n)
+  end
+
+  def spool_down_all
+    provider.spool_down_all
+  end
+
+  def refresh
+    provider.refresh
+  end
+
+  def sync
+    provider.sync
+  end
+
+  def execute(cmd)
+    provider.exec cmd
+  end
+
+  def root_execute(cmd)
+    provider.root_exec cmd
+  end
+
+  # copies current ssh known_hosts to a backup
+  def self.backup_ssh
+    `cp ~/.ssh/known_hosts ~/.ssh/known_hosts.backup`
+  end
+  # restores known_hosts file, destroying backup
+  def self.restore_ssh
+    `mv ~/.ssh/known_hosts.backup ~/.ssh/known_hosts`
+  end
+  # restores known_hosts file, keeping backup
+  def self.reset_ssh
+    `cp ~/.ssh/known_hosts.backup ~/.ssh/known_hosts`
+  end
+
+  def run_tests(n=1) # run 1 time, by default
+    output = []
+    n.times do
+      output << Cloudspeq::DistributedTesting.perform(@settings, provider.machines)
+    end
+    n == 1 ? output.first : output
+  end
+
+end

data/lib/cloudspeq/defaults.rb

@@ -0,0 +1,30 @@
+DEFAULT_SETTINGS = 
+{'provider_key'=>:digital_ocean,
+ 'spec_path'=>"spec",
+ 'user'=>"tester",
+ 'project_name'=>"myapp",
+ 'digital_ocean'=>
+  {"client_id"=>"xxx",
+   "api_key"=>"xxx",
+   "image_name"=>"xxx",
+   "ssh_key_name"=>"xxx",
+   "size_slug"=>"512mb",
+   "region_slug"=>"nyc2",
+   "machine_count"=>5,
+   },
+ 'machine_prefix'=>"test",
+ 'server_threads' => 1,
+ 'load_balance' => true,
+ 'server_lifetime' => 90,
+ 'file_pattern' => '/_spec.rb(:\d+)?\z/',
+ 'spec_line_pattern' => '/^(\s)+it|scenario/',
+ 'machine_file'=>"cloudspeq_machines.yml",
+ 'remote_command_prefix'=>"source .profile;",
+ 'remote_project_directory'=>"/home/tester/project",
+ 'remote_prepare'=>["bundle exec bin/rspec spec/spec_helper.rb"],
+ 'remote_clean_up'=>[],
+ 'local_clean_up' => [],
+ 'local_prepare' => [],
+ 'sync_excludes'=>["doc"]
+}
+

data/lib/cloudspeq/distributed_testing.rb

@@ -0,0 +1,128 @@
+require 'find'
+
+class Cloudspeq
+  class DistributedTesting
+    
+
+    def self.perform(settings,machines)
+      @settings = settings
+      @machines = machines.shuffle
+      @threads      = []
+      @outputs      = []
+      @proccessed   = []
+      @code_returns = []
+      time = Benchmark.measure do
+        test_princesses
+        test_remaining
+        @threads.each(&:join) 
+      end
+
+      {'time' => time.real, 'outputs' => @outputs}
+    end
+
+    private
+
+
+    def self.test_princesses
+      if @settings.princesses
+        specified_servers = @settings.princesses.reject{|k,v| k == 'misc'}
+        if specified_servers.empty?
+          specified_servers = @machines.count
+        else
+          specified_servers = specified_servers.collect{|k,v| v['servers']}.inject(:+) + 1
+        end
+        if specified_servers  > @machines.count
+          puts "ERROR: not enough servers. #{@machines.count} available, but #{specified_servers} needed"
+          return false
+        end
+        @settings.princesses.each do |k,v|
+          next if k == 'misc'
+          specs = parse_specs(k,v) - @proccessed
+          @proccessed.concat specs
+          issue_specs(specs.shuffle,v)
+        end
+      end
+    end
+
+    def self.test_remaining
+      remaining = parse_specs - @proccessed
+      if @settings.princesses && @settings.princesses['misc']
+        options = {'servers' => @machines.count, 'load_balance' => false, 'symbol' => '.'}.merge @settings.princesses['misc']
+      else
+        options = {'servers' => @machines.count, 'load_balance' => false}
+      end
+      issue_specs(remaining.shuffle, options)
+    end
+
+
+    # takes either a "valid" spec file, or directory. 
+    def self.parse_specs(path="",v={})
+      file_lines = []
+      if path.match(@settings.file_pattern)
+        proccess_lines(path,v)
+      else
+        Find.find("#{@settings.spec_path}/#{path}") do |file|
+          lines = proccess_lines(file,v)
+          next if lines.nil?
+          file_lines.concat lines
+        end
+        file_lines
+      end
+    end
+
+    def self.proccess_lines(file, v)
+      if v['load_balance'] && (v['load_balance'] == false)
+        return [file] 
+      elsif  @settings.load_balance == false
+        return [file]
+      end
+      if file.match(eval @settings.file_pattern)
+        lines = `awk '#{@settings.spec_line_pattern}{print NR}' #{file}`.split("\n")
+        return [] if lines.empty?
+        lines.collect do |line|
+          "#{file}:#{line}"
+        end
+      end 
+    end
+
+    def self.issue_specs(specs,v={'servers'=> 1})
+      threads = v['threads'].nil? ? @settings.server_threads : v['threads']
+      servers = v['servers'].nil? ? @machines.count : v['servers']
+      per = v['per'].nil?  ? specs.count / [v['servers'].to_i,1].max / threads : v['per']
+      per = per.ceil
+      puts "#{v['symbol'] || '.'} - #{specs.count} specs on #{servers} servers with #{per} specs per connection and #{threads} connections per server"
+      servers.times do
+        machine = @machines.pop # take a machine from the pool
+        threads.times do
+          @threads << create_thread(machine,specs,per,v)
+        end
+      end
+    end
+
+    def self.create_thread(machine,specs,per,v)
+      Thread.new do
+        files = []
+        while !specs.empty?
+          spec_lines = []
+          per.times{spec_lines << specs.pop}
+          output = nil
+          time = Benchmark.measure do
+            output = machine.exec("bundle exec bin/rspec -f j #{spec_lines.join(" ")}", @settings)
+          end
+          host_report = {"output" => (JSON.parse(output) rescue output), 
+                         "hostname" => machine.name, 
+                         "ip_address" => machine.ip_address, 
+                         "time" => time.real, 
+                         "specs" => spec_lines, 
+                         "symbol" => v['symbol']
+                       }
+          @outputs << host_report
+          print type_return = v['symbol'] || '.'
+          @code_returns << type_return
+        end
+      end
+    end
+
+
+  end
+end

data/lib/cloudspeq/providers/base.rb

@@ -0,0 +1,151 @@
+class Cloudspeq
+  class Providers
+    class Base
+      
+      def initialize(settings)
+        @settings = settings
+      end
+      
+      def refresh
+        @machines= remote_machines
+        write_machines @machines
+      end
+
+      def machines
+      end
+
+
+      def sync
+        machines.each do |machine|
+          machine.sync(@settings)
+        end
+      end
+
+      def sync
+        threads = []
+        output = {}
+        machines.each do |m| 
+          threads << Thread.new{ output[m.name] = m.sync(@settings) }
+        end
+        threads.each(&:join)
+        output
+      end
+
+      # destroys machines and removes
+      def destroy(machs)
+        machs.each do |m|
+          machines.delete m
+          m.destroy
+        end
+      end
+
+      def exec(command,machs=machines)
+        threads = []
+        output = {}
+        machs.each do |m| 
+          threads << Thread.new{ output[m.name] = m.exec(command,@settings) }
+        end
+        threads.each(&:join)
+        output
+      end
+
+      def exec!(command,machs=machines)
+        threads = []
+        machs.collect{|m| threads << Thread.new{m.exec! command, @settings}}
+        threads.each(&:join)
+      end
+
+      def root_exec(command,machs=machines)
+        threads = []
+        machs.collect{|m| threads << Thread.new{m.root_exec command}}
+        threads.each(&:join)
+      end
+
+      
+      def self.find(hostname: '', ip_address: '')
+        return false if hostname.empty? && ip_address.empty?  
+        if !ip_address.empty?
+        else
+        end
+      end
+      
+
+
+        private
+
+        def generate_machine_name(settings=@settings)
+          characters = ("a".."z").to_a + ('0'..'9').to_a
+          prefix = settings.machine_prefix ? "#{settings.machine_prefix}-" : "test-"
+          name = prefix + settings.project_name + "-" + characters.sample(4).join
+        end
+
+    end
+  end
+end
+
+
+
+class Cloudspeq
+  class Providers
+    class Base
+      class Machine
+
+        def initialize(machine)
+          @attributes = RecursiveOpenStruct.new(machine)
+        end
+
+        def attributes
+          @attributes
+        end
+
+        def shutdown
+        end
+
+        def restart
+        end
+
+        def startup
+        end
+
+        def destroy
+        end
+        
+        # most of the time, execution requires prefixing
+        def exec(command,settings)
+          user = settings.user
+          prefix = settings.command_prefix
+          command_exec(user,attributes.ip_address,prefix,command)
+        end
+
+        # execute without prefixing
+        def exec!(command,settings)
+          user = settings.user
+          prefix = settings.command_prefix
+          command_exec(user,attributes.ip_address,"",command)
+        end
+        
+        # exec as root
+        def root_exec(command)
+          command_exec('root',attributes.ip_address,"",command)
+        end
+
+        def sync(settings)
+          command = 'rsync -avz --delete -e "ssh -o StrictHostKeyChecking=no -x " '
+          command += "--exclude='.git/' --exclude='log/' --exclude='tmp/' "
+          settings.sync_excludes.each do |exc|
+            command += "--include='#{exc}' "
+          end
+          command += ". #{settings.user}@#{attributes.ip_address}:#{settings.remote_project_directory}"
+          `#{command}`
+        end
+
+        private
+
+        def command_exec(user,ip_address,prefix,command)
+          `ssh -o StrictHostKeyChecking=no -x -C #{user}@#{attributes.ip_address} "#{prefix} #{command}"`
+        end
+
+      end
+    end
+  end
+end

data/lib/cloudspeq/providers/digital_ocean.rb

@@ -0,0 +1,125 @@
+class Cloudspeq
+  class Providers
+    class DigitalOcean < Base
+
+      def initialize(settings)
+        ::Digitalocean.client_id  = settings.digital_ocean['client_id']
+        ::Digitalocean.api_key    = settings.digital_ocean['api_key']
+        @settings =               settings
+        @digital  =               settings.digital_ocean
+        @machines =               machines
+      end
+
+      def provider_settings
+        @digital
+      end
+
+      def create(count=@digital['machine_count'])
+        created = []
+        count.to_i.times do 
+          response = Digitalocean::Droplet.create({name: generate_machine_name, 
+                                                   size_id: size.id, 
+                                                   image_id: image.id, 
+                                                   region_id: region.id, 
+                                                   ssh_key_ids: ssh_key.id})
+          if response.status == "OK"
+            created << response.droplet
+          else
+            puts response
+          end
+        end
+        created.each do |machine|
+          @machines << Machine.new(Digitalocean::Droplet.find(machine.id).droplet.to_h)
+        end
+      
+      end
+
+      def machines(file='cloudspeq_machines.yml')
+        File.write(file, '') unless File.exist?(file)
+        yaml = YAML.load_file(file)
+        yaml =  [] if yaml == false
+        yaml.class == Array ? yaml : [yaml]
+      end
+
+      # by default, only grab machines that look like they're related to testing
+      # be careful if you set this to true and have other machines on your account
+      def remote_machines(all=false)
+        if all
+         machines = ::Digitalocean::Droplet.all
+        else
+          string = @settings.machine_prefix ? "#{@settings.machine_prefix}-" : "test-"
+          machines = ::Digitalocean::Droplet.all.droplets.select{|d| d.name.start_with?(string)}
+        end
+        machines.collect{|m| Machine.new(m)}
+      end
+
+      def write_machines(machs,file=@digital['machine_file'])
+        @machines= machs
+        File.open(file,"w") do |f|
+          f.write(machs.to_yaml)
+        end
+        
+      end
+
+      def image
+        ::Digitalocean::Image.all.images.select{|i| i.name == @digital['image_name']}.first
+      end
+
+      def ssh_key
+        ::Digitalocean::SshKey.all.ssh_keys.select{|i| i.name == @digital['ssh_key_name']}.first
+      end
+
+      def size
+        ::Digitalocean::Size.all.sizes.select{|s| s.slug == @digital['size_slug']}.first
+      end
+
+      def region
+        ::Digitalocean::Region.all.regions.select{|r| r.slug == @digital['region_slug']}.first
+      end
+
+      def status
+        status_hashes = machines.collect {|m| {"#{m.attributes.name}" => m.attributes.status} }
+        statuses = status_hashes.collect{|m| m.values}.flatten
+        new_machines = statuses.select{|m| m == 'new'}
+        active_machines = statuses.select{|m| m == 'active'}
+        {'total' => statuses.count, 'new' => new_machines.count, 'active' => active_machines.count, 'machines' => status_hashes}
+      end
+
+      def spool_down_all
+        destroy remote_machines
+      end
+
+
+
+
+      class Machine < Base::Machine
+
+        def name
+          attributes.name
+        end
+
+        def ip_address
+          attributes.ip_address
+        end
+
+        def power_off
+          ::Digitalocean::Droplet.power_off(attributes.id)
+        end
+
+        def power_cycle
+          ::Digitalocean::Droplet.power_cycle(attributes.id)
+        end
+
+        def power_on
+          ::Digitalocean::Droplet.power_on(attributes.id)
+        end
+
+        def destroy
+          ::Digitalocean::Droplet.destroy(attributes.id)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/cloudspeq/rspec_outputter.rb

@@ -0,0 +1,59 @@
+class Cloudspeq
+  class RspecOutputter
+
+    def self.color(color, text)
+      colors = {red: "0;31", 
+                blue: '0;34', 
+                green: '0;32', 
+                yellow: '1;33', 
+                light_green: '1;32', 
+                light_red:'1;31', 
+                light_blue: '1;34',
+                purple: '0;35',
+                light_purple: '1;35'
+              }
+    "\033[#{colors[color]}m #{text} \033[0m"
+    end
+
+
+    def self.perform(outputs)
+      puts "\n\n ***** Spec Report *****\n\n"
+      @failures = []
+      @outputs = outputs['outputs']
+      output_summary_lines
+      output_failures
+      puts "Total Time: #{outputs['time']}"
+    end
+
+    private
+
+    def self.output_summary_lines
+      @outputs.each do |o| 
+        puts "#{o['symbol'] || '.'} - #{o['hostname']}: #{o['time'].to_s}  #{o['output']['summary_line'] rescue 'unexpected output'}" 
+      end
+    end
+
+    def self.collect_failures
+      @outputs.each do |o|
+        if o['output']['examples']
+          fails = o['output']['examples'].select{|t| t['status'] == 'failed'}
+          fails.each do |f|
+            @failures << "#{o['symbol'] || '.'} - #{o['hostname']}: #{f['file_path']}:#{f['line_number']} #{f['exception']['message']}"
+          end
+        end
+      end
+    end
+
+    def self.output_failures
+      collect_failures
+      if !@failures.empty?
+        puts "\n\nFailures:"
+        @failures.each{|f| puts color(:red, f)}
+        puts "Total Failures: #{@failures.size.to_s}"
+      else
+        puts color(:green, "No Failures!")
+      end
+    end
+
+  end
+end

data/lib/cloudspeq/version.rb

@@ -0,0 +1,3 @@
+class Cloudspeq
+  VERSION = "0.0.15"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: cloudspeq
+version: !ruby/object:Gem::Version
+  version: 0.0.15
+platform: ruby
+authors:
+- Russell Jennings
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: escort
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: digitalocean
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Having a slow test suite sucks. But don't let a slow test suite slow
+  you down! with cloudspeq you can distribute your tests and dramatically reduce the
+  time it takes to test.
+email:
+- violentpurr@gmail.com
+executables:
+- cloudspeq
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/cloudspeq
+- cloudspeq.gemspec
+- lib/cloudspeq.rb
+- lib/cloudspeq/defaults.rb
+- lib/cloudspeq/distributed_testing.rb
+- lib/cloudspeq/providers/base.rb
+- lib/cloudspeq/providers/digital_ocean.rb
+- lib/cloudspeq/rspec_outputter.rb
+- lib/cloudspeq/version.rb
+homepage: https://github.com/meesterdude/cloudspeq
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Distribute your tests in the cloud for faster development in slow test suits
+test_files: []