corl 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  metadata.gz: 7a8900e16b96f2022f8c52ed251802c43e5a9224
-  data.tar.gz: 357559d77d1dd84501a5284cbb199cd0c631d239
-SHA512: 
-  metadata.gz: febc1d9a88160e7066180c423cf6fe2d3a5d610a3dd4a988c79873e55a5590d4e27221c29c9067bdca02eee11dd04b985cdf6668902ecd1fbac788374200bc3b
-  data.tar.gz: 3cc2e3bd2070075ce89166b1802f6049f68af56e027512ca16f1283a23e84cf1e49de6b0400964cba7376d844ce433a75ee83b31aeb21c744dc6bff415c08c14
+---
+SHA1:
+  metadata.gz: 316f191cc1156d9936eac3c2dd380d597c221f9e
+  data.tar.gz: 6d5d7475ca709a66e073b531a4b0851572d45556
+SHA512:
+  metadata.gz: 9a39a6f7959c64870c9bce05081e0fd587b4b55f2bd8b1e0fbad52900fe5ee75da732a71684c8afeb512c5ef7906871dec7b184bd6ad65334170b0638d57d675
+  data.tar.gz: 792a4c8c53f7b4f3f875d6f1e94bea2c3f57f9579f28ec4befe2cd3daf802bbd8cbea53757c8272785c3962023db1294c54b8b29e851fc68b999766041dc6cd1

data/README.rdoc

@@ -1,27 +1,592 @@
-=== CORL (Coral Orchestration and Research Library)
+# CORL - Coral Orchestration and Research Library
 
-Coming soon!
+[Nucleon](https://github.com/coralnexus/nucleon) plugin library and framework for building, synchronizing, and executing 
+distributed actions and agents across heterogenous networks.
 
-Note:  This library is still very early in development!
+[Nucleon](https://github.com/coralnexus/nucleon) powered 
 
-==== Contributing to CORL
- 
-* Check out the latest {major}.{minor} branch to make sure the feature hasn't 
-  been implemented or the bug hasn't been fixed yet.
-* Check out the issue tracker to make sure someone already hasn't requested 
-  it and/or contributed it.
-* Fork the project.
-* Start a feature/bugfix branch.
-* Commit and push until you are happy with your contribution.
-* If possible, add tests for it. This is important so I don't break it in a 
-  future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want 
-  to have your own version, or is otherwise necessary, that is fine, but 
-  please isolate to its own commit so I can cherry-pick around it.
 
-==== Copyright
 
-Licensed under Apache License 2.0.  See LICENSE.txt for further details.
 
-Copyright (c) 2013-2014  Adrian Webb <adrian.webb@coralnexus.com>
-Coral Technology Group LLC
+
+
+
+
+
+
+
+
+
+
+
+![Logo][logo]
+[logo]: http://cl.ly/image/3Y013H0A2z3z/gundam-ruby.png
+
+Upgrading? Check the [Upgrade Guide](#upgrading-guide) before bumping to a new
+[major version][semver].
+
+## Philosophy
+
+API wrappers [should reflect the idioms of the language in which they were
+written][wrappers]. Octokit.rb wraps the [GitHub API][github-api] in a flat API
+client that follows Ruby conventions and requires little knowledge of REST.
+Most methods have positional arguments for required input and an options hash
+for optional parameters, headers, or other options:
+
+```ruby
+# Fetch a README with Accept header for HTML format
+Octokit.readme 'al3x/sovereign', :accept => 'application/vnd.github.html'
+```
+
+
+[wrappers]: http://wynnnetherland.com/journal/what-makes-a-good-api-wrapper
+[github-api]: http://developer.github.com
+
+## Quick start
+
+Install via Rubygems
+
+    gem install octokit
+
+... or add to your Gemfile
+
+    gem "octokit", "~> 3.0"
+
+### Making requests
+
+[API methods][] are available as module methods (consuming module-level
+configuration) or as client instance methods.
+
+```ruby
+# Provide authentication credentials
+Octokit.configure do |c|
+  c.login = 'defunkt'
+  c.password = 'c0d3b4ssssss!'
+end
+
+# Fetch the current user
+Octokit.user
+```
+or
+
+```ruby
+# Provide authentication credentials
+client = Octokit::Client.new(:login => 'defunkt', :password => 'c0d3b4ssssss!')
+# Fetch the current user
+client.user
+```
+
+[API methods]: http://octokit.github.io/octokit.rb/method_list.html
+
+### Consuming resources
+
+Most methods return a `Resource` object which provides dot notation and `[]`
+access for fields returned in the API response.
+
+```ruby
+# Fetch a user
+user = Octokit.user 'jbarnette'
+puts user.name
+# => "John Barnette"
+puts user.fields
+# => <Set: {:login, :id, :gravatar_id, :type, :name, :company, :blog, :location, :email, :hireable, :bio, :public_repos, :followers, :following, :created_at, :updated_at, :public_gists}>
+puts user[:company]
+# => "GitHub"
+user.rels[:gists].href
+# => "https://api.github.com/users/jbarnette/gists"
+```
+
+**Note:** URL fields are culled into a separate `.rels` collection for easier
+[Hypermedia](#hypermedia-agent) support.
+
+### Accessing HTTP responses
+
+While most methods return a `Resource` object or a Boolean, sometimes you may
+need access to the raw HTTP response headers. You can access the last HTTP
+response with `Client#last_response`:
+
+```ruby
+user      = Octokit.user 'andrewpthorp'
+response  = Octokit.last_response
+etag      = response.headers[:etag]
+```
+
+## Authentication
+
+Octokit supports the various [authentication methods supported by the GitHub
+API][auth]:
+
+### Basic Authentication
+
+Using your GitHub username and password is the easiest way to get started
+making authenticated requests:
+
+```ruby
+client = Octokit::Client.new \
+  :login    => 'defunkt',
+  :password => 'c0d3b4ssssss!'
+
+user = client.user
+user.login
+# => "defunkt"
+```
+While Basic Authentication allows you to get started quickly, OAuth access
+tokens are the preferred way to authenticate on behalf of users.
+
+### OAuth access tokens
+
+[OAuth access tokens][oauth] provide two main benefits over using your username
+and password:
+
+* **Revokable access**. Access tokens can be revoked, removing access for only
+  that token without having to change your password everywhere.
+* **Limited access**. Access tokens have [access scopes][] which allow for more
+  granular access to API resources. For instance, you can grant a third party
+  access to your gists but not your private repositories.
+
+To use an access token with the Octokit client, pass your token in the
+`:access_token` options parameter in lieu of your username and password:
+
+```ruby
+client = Octokit::Client.new(:access_token => "<your 40 char token>")
+
+user = client.user
+user.login
+# => "defunkt"
+```
+
+You can [create access tokens through your GitHub Account Settings](https://help.github.com/articles/creating-an-access-token-for-command-line-use)
+or with a basic authenticated Octokit client:
+
+```ruby
+client = Octokit::Client.new \
+  :login    => 'defunkt',
+  :password => 'c0d3b4ssssss!'
+
+client.create_authorization(:scopes => ["user"], :note => "Name of token")
+# => <your new oauth token>
+```
+
+### Two-Factor Authentication
+
+[Two-Factor Authentication](https://help.github.com/articles/about-two-factor-authentication) brings added security to the account by requiring more information to login.
+
+Using two-factor authentication for API calls is as simple as adding the [required header](http://developer.github.com/v3/auth/#working-with-two-factor-authentication) as an option:
+
+```ruby
+client = Octokit::Client.new \
+  :login    => 'defunkt',
+  :password => 'c0d3b4ssssss!'
+
+user = client.user("defunkt", :headers => { "X-GitHub-OTP" => "<your 2FA token>" })
+```
+
+As you can imagine, this gets annoying quick since two-factor auth tokens are very short lived. So it is recommended to create an oauth token for the user to communicate with the API:
+
+```ruby
+client = Octokit::Client.new \
+  :login    => 'defunkt',
+  :password => 'c0d3b4ssssss!'
+
+client.create_authorization(:scopes => ["user"], :note => "Name of token",
+                            :headers => { "X-GitHub-OTP" => "<your 2FA token>" })
+# => <your new oauth token>
+```
+
+### Using a .netrc file
+
+Octokit supports reading credentials from a netrc file (defaulting to
+`~/.netrc`).  Given these lines in your netrc:
+
+```
+machine api.github.com
+  login defunkt
+  password c0d3b4ssssss!
+```
+You can now create a client with those credentials:
+
+```ruby
+client = Octokit::Client.new(:netrc => true)
+client.login
+# => "defunkt"
+```
+But _I want to use OAuth_ you say. Since the GitHub API supports using an OAuth
+token as a Basic password, you totally can:
+
+```
+machine api.github.com
+  login defunkt
+  password <your 40 char token>
+```
+
+**Note:** Support for netrc requires adding the [netrc gem][] to your Gemfile
+or `.gemspec`.
+
+### Application authentication
+
+Octokit also supports application-only authentication [using OAuth application client
+credentials][app-creds]. Using application credentials will result in making
+anonymous API calls on behalf of an application in order to take advantage of
+the higher rate limit.
+
+```ruby
+client = Octokit::Client.new \
+  :client_id     => "<your 20 char id>",
+  :client_secret => "<your 40 char secret>"
+
+user = client.user 'defunkt'
+```
+
+[auth]: http://developer.github.com/v3/#authentication
+[oauth]: http://developer.github.com/v3/oauth/
+[access scopes]: http://developer.github.com/v3/oauth/#scopes
+[app-creds]: http://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications
+
+## Pagination
+
+Many GitHub API resources are [paginated][]. While you may be tempted to start
+adding `:page` parameters to your calls, the API returns links to the next,
+previous, and last pages for you in the `Link` response header as [Hypermedia
+link relations](#hypermedia-agent).
+
+```ruby
+issues = Octokit.issues 'rails/rails', :per_page => 100
+issues.concat Octokit.last_response.rels[:next].get.data
+```
+
+### Auto pagination
+
+For smallish resource lists, Octokit provides auto pagination. When this is
+enabled, calls for paginated resources will fetch and concatenate the results
+from every page into a single array:
+
+```ruby
+Octokit.auto_paginate = true
+issues = Octokit.issues 'rails/rails'
+issues.length
+
+# => 702
+```
+
+**Note:** While Octokit auto pagination will set the page size to the maximum
+`100`, and seek to not overstep your rate limit, you probably want to use a
+custom pattern for traversing large lists.
+
+[paginated]: http://developer.github.com/v3/#pagination
+
+## Configuration and defaults
+
+While `Octokit::Client` accepts a range of options when creating a new client
+instance, Octokit's configuration API allows you to set your configuration
+options at the module level. This is particularly handy if you're creating a
+number of client instances based on some shared defaults.
+
+### Configuring module defaults
+
+Every writable attribute in {Octokit::Configurable} can be set one at a time:
+
+```ruby
+Octokit.api_endpoint = 'http://api.github.dev'
+Octokit.web_endpoint = 'http://github.dev'
+```
+
+or in batch:
+
+```ruby
+Octokit.configure do |c|
+  c.api_endpoint = 'http://api.github.dev'
+  c.web_endpoint = 'http://github.dev'
+end
+```
+
+### Using ENV variables
+
+Default configuration values are specified in {Octokit::Default}. Many
+attributes will look for a default value from the ENV before returning
+Octokit's default.
+
+```ruby
+# Given $OCTOKIT_API_ENDPOINT is "http://api.github.dev"
+Octokit.api_endpoint
+
+# => "http://api.github.dev"
+```
+
+Deprecation warnings and API endpoints in development preview warnings are
+printed to STDOUT by default, these can be disabled by setting the ENV
+`OCTOKIT_SILENT=true`.
+
+## Hypermedia agent
+
+Starting in version 2.0, Octokit is [hypermedia][]-enabled. Under the hood,
+{Octokit::Client} uses [Sawyer][], a hypermedia client built on [Faraday][].
+
+### Hypermedia in Octokit
+
+Resources returned by Octokit methods contain not only data but hypermedia
+link relations:
+
+```ruby
+user = Octokit.user 'technoweenie'
+
+# Get the repos rel, returned from the API
+# as repos_url in the resource
+user.rels[:repos].href
+# => "https://api.github.com/users/technoweenie/repos"
+
+repos = user.rels[:repos].get.data
+repos.last.name
+# => "faraday-zeromq"
+```
+
+When processing API responses, all `*_url` attributes are culled in to the link
+relations collection. Any `url` attribute becomes `.rels[:self]`.
+
+### URI templates
+
+You might notice many link relations have variable placeholders. Octokit
+supports [URI Templates][uri-templates] for parameterized URI expansion:
+
+```ruby
+repo = Octokit.repo 'pengwynn/pingwynn'
+rel = repo.rels[:issues]
+# => #<Sawyer::Relation: issues: get https://api.github.com/repos/pengwynn/pingwynn/issues{/number}>
+
+# Get a page of issues
+rel.get.data
+
+# Get issue #2
+rel.get(:uri => {:number => 2}).data
+```
+
+### The Full Hypermedia Experience™
+
+If you want to use Octokit as a pure hypermedia API client, you can start at
+the API root and follow link relations from there:
+
+```ruby
+root = Octokit.root
+root.rels[:repository].get :uri => {:owner => "octokit", :repo => "octokit.rb" }
+```
+
+Octokit 3.0 aims to be hypermedia-driven, removing the internal URL
+construction currently used throughout the client.
+
+[hypermedia]: http://en.wikipedia.org/wiki/Hypermedia
+[Sawyer]: https://github.com/lostisland/sawyer
+[Faraday]: https://github.com/lostisland/faraday
+[uri-templates]: http://tools.ietf.org/html/rfc6570
+
+## Upgrading guide
+
+Version 3.0 includes a couple breaking changes when upgrading from v2.x.x:
+
+The [default media type][default-media-type] is now `v3` instead of `beta`. If
+you need to request the older media type, you can set the default media type
+for the client:
+
+```ruby
+Octokit.default_media_type = "application/vnd.github.beta+json"
+```
+or per-request
+
+```ruby
+Octokit.emails(:accept => "application/vnd.github.beta+json")
+```
+
+The long-deprecated `Octokit::Client#create_download` method has been removed.
+
+[default-media-type]: https://developer.github.com/changes/2014-01-07-upcoming-change-to-default-media-type/
+
+### Upgrading from 1.x.x
+
+Version 2.0 includes a completely rewritten `Client` factory that now memoizes
+client instances based on unique configuration options. Breaking changes also
+include:
+
+* `:oauth_token` is now `:access_token`
+* `:auto_traversal` is now `:auto_paginate`
+* `Hashie::Mash` has been removed. Responses now return a `Sawyer::Resource`
+  object. This new type behaves mostly like a Ruby `Hash`, but does not fully
+  support the `Hashie::Mash` API.
+* Two new client error types are raised where appropriate:
+  `Octokit::TooManyRequests` and `Octokit::TooManyLoginAttempts`
+* The `search_*` methods from v1.x are now found at `legacy_search_*`
+* Support for netrc requires including the [netrc gem][] in your Gemfile or
+  gemspec.
+* DateTime fields are now proper `DateTime` objects. Previous versions outputted DateTime fields as 'String' objects.
+
+[netrc gem]: https://rubygems.org/gems/netrc
+
+
+## Advanced usage
+
+Since Octokit employs [Faraday][faraday] under the hood, some behavior can be
+extended via middleware.
+
+### Debugging
+
+Often, it helps to know what Octokit is doing under the hood. You can add a
+logger to the middleware that enables you to peek into the underlying HTTP
+traffic:
+
+```ruby
+stack = Faraday::RackBuilder.new do |builder|
+  builder.response :logger
+  builder.use Octokit::Response::RaiseError
+  builder.adapter Faraday.default_adapter
+end
+Octokit.middleware = stack
+Octokit.user 'pengwynn'
+```
+```
+I, [2013-08-22T15:54:38.583300 #88227]  INFO -- : get https://api.github.com/users/pengwynn
+D, [2013-08-22T15:54:38.583401 #88227] DEBUG -- request: Accept: "application/vnd.github.beta+json"
+User-Agent: "Octokit Ruby Gem 2.0.0.rc4"
+I, [2013-08-22T15:54:38.843313 #88227]  INFO -- Status: 200
+D, [2013-08-22T15:54:38.843459 #88227] DEBUG -- response: server: "GitHub.com"
+date: "Thu, 22 Aug 2013 20:54:40 GMT"
+content-type: "application/json; charset=utf-8"
+transfer-encoding: "chunked"
+connection: "close"
+status: "200 OK"
+x-ratelimit-limit: "60"
+x-ratelimit-remaining: "39"
+x-ratelimit-reset: "1377205443"
+...
+```
+
+See the [Faraday README][faraday] for more middleware magic.
+
+### Caching
+
+If you want to boost performance, stretch your API rate limit, or avoid paying
+the hypermedia tax, you can use [Faraday Http Cache][cache].
+
+Add the gem to your Gemfile
+
+    gem 'faraday-http-cache'
+
+Next, construct your own Faraday middleware:
+
+```ruby
+stack = Faraday::RackBuilder.new do |builder|
+  builder.use Faraday::HttpCache
+  builder.use Octokit::Response::RaiseError
+  builder.adapter Faraday.default_adapter
+end
+Octokit.middleware = stack
+```
+
+Once configured, the middleware will store responses in cache based on ETag
+fingerprint and serve those back up for future `304` responses for the same
+resource. See the [project README][cache] for advanced usage.
+
+
+[cache]: https://github.com/plataformatec/faraday-http-cache
+[faraday]: https://github.com/lostisland/faraday
+
+## Hacking on Octokit.rb
+
+If you want to hack on Octokit locally, we try to make [bootstrapping the
+project][bootstrapping] as painless as possible. To start hacking, clone and run:
+
+    script/bootstrap
+
+This will install project dependencies and get you up and running. If you want
+to run a Ruby console to poke on Octokit, you can crank one up with:
+
+    script/console
+
+Using the scripts in `./scripts` instead of `bundle exec rspec`, `bundle
+console`, etc.  ensures your dependencies are up-to-date.
+
+### Running and writing new tests
+
+Octokit uses [VCR][] for recording and playing back API fixtures during test
+runs. These cassettes (fixtures) are part of the Git project in the `spec/cassettes`
+folder. If you're not recording new cassettes you can run the specs with existing
+cassettes with:
+
+    script/test
+
+Octokit uses environmental variables for storing credentials used in testing.
+If you are testing an API endpoint that doesn't require authentication, you
+can get away without any additional configuration. For the most part, tests
+use an authenticated client, using a token stored in `ENV['OCTOKIT_TEST_GITHUB_TOKEN']`.
+There are several different authenticating method's used across the api.
+Here is the full list of configurable environmental variables for testing
+Octokit:
+
+ENV Variable | Description |
+:-------------------|:-----------------|
+`OCTOKIT_TEST_GITHUB_LOGIN`| GitHub login name (preferably one created specifically for testing against).
+`OCTOKIT_TEST_GITHUB_PASSWORD`| Password for the test GitHub login.
+`OCTOKIT_TEST_GITHUB_TOKEN` | [Personal Access Token](https://github.com/blog/1509-personal-api-tokens) for the test GitHub login.
+`OCTOKIT_TEST_GITHUB_CLIENT_ID` | Test OAuth application client id.
+`OCTOKIT_TEST_GITHUB_CLIENT_SECRET` | Test OAuth application client secret.
+`OCTOKIT_TEST_GITHUB_REPOSITORY` | Test repository to perform destructive actions against, this should not be set to any repository of importance. **Automatically created by the test suite if nonexistent** Default: `api-sandbox`
+`OCTOKIT_TEST_GITHUB_ORGANIZATION` | Test organization.
+
+Since we periodically refresh our cassettes, please keep some points in mind
+when writing new specs.
+
+* **Specs should be idempotent**. The HTTP calls made during a spec should be
+  able to be run over and over. This means deleting a known resource prior to
+  creating it if the name has to be unique.
+* **Specs should be able to be run in random order.** If a spec depends on
+  another resource as a fixture, make sure that's created in the scope of the
+  spec and not depend on a previous spec to create the data needed.
+* **Do not depend on authenticated user info.** Instead of asserting
+  actual values in resources, try to assert the existence of a key or that a
+  response is an Array. We're testing the client, not the API.
+
+[bootstrapping]: http://wynnnetherland.com/linked/2013012801/bootstrapping-consistency
+[VCR]: https://github.com/vcr/vcr
+
+## Supported Ruby Versions
+
+This library aims to support and is [tested against][travis] the following Ruby
+implementations:
+
+* Ruby 1.9.2
+* Ruby 1.9.3
+* Ruby 2.0.0
+* Ruby 2.1.0
+
+If something doesn't work on one of these Ruby versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby
+implementations, but support will only be provided for the versions listed
+above.
+
+If you would like this library to support another Ruby version, you may
+volunteer to be a maintainer. Being a maintainer entails making sure all tests
+run and pass on that implementation. When something breaks on your
+implementation, you will be responsible for providing patches in a timely
+fashion. If critical issues for a particular implementation exist at the time
+of a major release, support for that Ruby version may be dropped.
+
+[travis]: https://travis-ci.org/octokit/octokit.rb
+
+## Versioning
+
+This library aims to adhere to [Semantic Versioning 2.0.0][semver]. Violations
+of this scheme should be reported as bugs. Specifically, if a minor or patch
+version is released that breaks backward compatibility, that version should be
+immediately yanked and/or a new version should be immediately released that
+restores compatibility. Breaking changes to the public API will only be
+introduced with new major versions. As a result of this policy, you can (and
+should) specify a dependency on this gem using the [Pessimistic Version
+Constraint][pvc] with two digits of precision. For example:
+
+    spec.add_dependency 'octokit', '~> 3.0'
+
+[semver]: http://semver.org/
+[pvc]: http://guides.rubygems.org/patterns/#pessimistic-version-constraint
+
+## License
+
+Licensed under Apache License 2.0. See LICENSE.txt for further details.
+
+Copyright © 2013-2014 Adrian Webb <adrian.webb@coralnexus.com> Coral Technology Group LLC

data/VERSION

@@ -1 +1 @@
-0.5.5
+0.5.6

data/bootstrap/os/ubuntu/05_ruby.sh

@@ -60,7 +60,7 @@ do
   fi
 done
 
-echo "5. Installing Rubinius -- this will take some time"
+echo "5. Installing Ruby version $RUBY_RVM_VERSION -- this might take some time"
 
 if [ -z "$RUBY_RVM_VERSION" ]
 then

data/corl.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: corl 0.5.5 ruby lib
+# stub: corl 0.5.6 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "corl"
-  s.version = "0.5.5"
+  s.version = "0.5.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Adrian Webb"]
-  s.date = "2014-12-27"
+  s.date = "2014-12-29"
   s.description = "Framework that provides a simple foundation for growing organically in the cloud"
   s.email = "adrian.webb@coralnexus.com"
   s.executables = ["corl"]
@@ -171,7 +171,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--title", "Coral Orchestration and Research Library", "--main", "README.rdoc", "--line-numbers"]
   s.required_ruby_version = Gem::Requirement.new(">= 1.9.1")
   s.rubyforge_project = "corl"
-  s.rubygems_version = "2.4.2"
+  s.rubygems_version = "2.4.3"
   s.summary = "Coral Orchestration and Research Library"
 
   if s.respond_to? :specification_version then

data/lib/CORL/provisioner/puppetnode.rb

@@ -260,7 +260,7 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
 
       @@puppet_lock.synchronize do
         begin
-          info("Starting catalog generation", { :i18n => false })
+          info("Starting catalog generation at #{Time.now.to_s}", { :i18n => false })
 
           @@status[id] = code.success
           @@network    = network
@@ -297,7 +297,7 @@ class Puppetnode < Nucleon.plugin_class(:CORL, :provisioner)
 
             unless config.get(:dry_run, false)
               info("\n", { :prefix => false, :i18n => false })
-              info("Starting configuration run", { :i18n => false })
+              info("Starting configuration run at #{Time.now.to_s}", { :i18n => false })
 
               # Configure the machine
               Puppet.push_context({ :current_environment => apply_environment }, "CORL environment for configurer transaction")

data/lib/core/plugin/fog_machine.rb

@@ -40,6 +40,8 @@ class FogBase < Nucleon.plugin_class(:CORL, :machine)
     ENV['DEBUG'] = 'true' if CORL.log_level == :debug
 
     require 'fog'
+    Fog.timeout = 1000
+
     yield if block_given?
 
     myself.compute = ::Fog::Compute.new(export)