pvcglue 0.1.15 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 00890a0aee116c26c18b222c0300897a80cd6497
-  data.tar.gz: 6c68aa88436df5bc55ba9fc0066a0720d976a79f
+  metadata.gz: 5317c0a638c5ddacd0a3ee767d7754caa2c04848
+  data.tar.gz: 7342a1125dcc1b35fcbb969043455bc8a99c734c
 SHA512:
-  metadata.gz: 468eda830f2fd105ccd014bf5c4149d2f4c346ec273b707bf896579be248283806faf5fa779a24935c2ac804325c911f6bd6360dbd7db8955b7cba4c4529396b
-  data.tar.gz: 65520aed3aead87f2789c8fb7714f93f88421db12720c2e1498b3c8f646e8c3498ee0d4483abc9e8983bbf30e22ee63fe6cf03e53f159aa3a3a874d4f5eeecab
+  metadata.gz: eac0304984a7caa026023d250da35441a8b95aa3e4755d9c5efc12175b8cee108f1ef5e96af81b4654028905f535f8ce99e72bd0695bf7fdf307a60f788c2838
+  data.tar.gz: a9e4d18207fe3eb2a920125ab4e2df1bf6174957b1f06b874096d62ae7b8d786798b0f17dd9851d2c21847b627d83cb65f068c06a2908d809dddbf6045d25e54

data/.gitignore

@@ -1,3 +1,4 @@
+/.idea
 *.gem
 *.rbc
 .bundle

data/README.md

@@ -1,6 +1,6 @@
 # PVC Glue
 
-Pico Virtual Cloud
+Pico Virtual Cloud Glue creates a tightly integrated (very small) virtual cloud for your Rails application.
 
 An opinionated cloud application manager for Rails applications using your own servers.
 
@@ -158,7 +158,7 @@ Add these lines to your application's Gemfile.  `dotenv-rails` must be listed fi
 
 Then add these lines to your application's Gemfile, whereever you like (usually at the end):
 
-    gem 'pvcglue', "~> 0.1.12", :group => :development
+    gem 'pvcglue', "~> 0.1.15", :group => :development
     gem 'pvcglue_dbutils', "~> 0.5.3"
 
 And then execute:

data/bin/pvc

@@ -4,11 +4,11 @@ require 'pvcglue/cli'
 # Allow use of Capistrano style environment syntax and convert to 'standard' syntax
 # Example:  `pvc production bootstrap` ==> `pvc bootstrap --stage=production`
 # TODO: refactor to use a list of user specified environments
-if ARGV.count >= 2 && %w[alpha beta gamma delta preview production staging all].include?(ARGV[0])
+if ARGV.count >= 2 && %w[local test alpha beta gamma delta preview production staging all].include?(ARGV[0])
   ARGV[0], ARGV[1] = ARGV[1], "--stage=#{ARGV[0]}"
 end
 
 # puts ARGV.inspect
 
 Pvcglue::CLI.start
-puts "Done."
+puts "----- Done -----"

data/lib/pvcglue.rb

@@ -12,6 +12,7 @@ require "pvcglue/capistrano"
 require "pvcglue/ssl"
 require "pvcglue/db"
 require "pvcglue/toml_pvc_dumper.rb"
+require "pvcglue/local.rb"
 require "tilt"
 
 # puts File.join(File.dirname(__FILE__), 'pvcglue', 'packages', '*.rb')

data/lib/pvcglue/capistrano.rb

@@ -31,5 +31,9 @@ module Pvcglue
     def self.deploy
       system("cap #{Pvcglue.cloud.stage_name} deploy")
     end
+
+    def self.rake(params)
+      system("cap #{Pvcglue.cloud.stage_name} invoke[#{params.join(" ")}]")
+    end
   end
 end

data/lib/pvcglue/cli.rb

@@ -148,6 +148,24 @@ module Pvcglue
       sh(server)
     end
 
+    desc "deploy", "deploy the app"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def deploy
+      Pvcglue::Capistrano.deploy
+    end
+
+    desc "rake", "run rake task on remote stage"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def rake(*tasks)
+      if Pvcglue.cloud.stage_name == 'production'
+      # if Pvcglue.cloud.stage_name == 'local'
+        raise(Thor::Error, "\nDidn't think so!\n") unless yes?("\n\nStop!  Think!  Are you sure you want to do this on the #{Pvcglue.cloud.stage_name} stage? (y/N)")
+      end
+      Pvcglue::Capistrano.rake(tasks)
+    end
+
     desc "pvcify", "update capistrano, database.yml and other configurations"
     method_option :stage, :required => true, :aliases => "-s"
 
@@ -156,12 +174,70 @@ module Pvcglue
       Pvcglue::Db.configure_database_yml
     end
 
-    desc "deploy", "deploy the app"
+    desc "start", "start local virtual machines (build first, if required)"
     method_option :stage, :required => true, :aliases => "-s"
 
-    def deploy
-      Pvcglue::Capistrano.deploy
+    def start
+      Pvcglue::Local.start
+    end
+
+    desc "stop", "shut down local virtual machines"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def stop
+      Pvcglue::Local.stop
+    end
+
+    desc "restart", "stop and then start local virtual machines"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def restart
+      Pvcglue::Local.restart
+    end
+
+    desc "destroy", "destory local virtual machines"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def destroy
+      Pvcglue::Local.destroy
+    end
+
+    desc "suspend", "suspend local virtual machines"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def suspend
+      Pvcglue::Local.suspend
+    end
+
+    desc "status", "show status of local virtual machines"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def status
+      Pvcglue::Local.status
+    end
+
+    desc "kill", "force shutdown (power off) local virtual machines - may cause data corruption"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def kill
+      Pvcglue::Local.kill
+    end
+
+    desc "rebuild", "destroy, build and start local virtual machines"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def rebuild
+      Pvcglue::Local.rebuild
     end
+
+    desc "update_config", "debug use"
+    method_option :stage, :required => true, :aliases => "-s"
+
+    def update_config
+      Pvcglue::Local.update_local_config_from_cache
+    end
+
+
   end
 
 end

data/lib/pvcglue/configuration.rb

@@ -9,6 +9,7 @@ module Pvcglue
   class Configuration < Thor
 
     attr_accessor :cloud_manager
+    attr_accessor :local_cloud_manager
     attr_accessor :cloud_name
     attr_accessor :application_name
     attr_accessor :context
@@ -21,19 +22,36 @@ module Pvcglue
       ENV['PVCGLUE_ENV_PREFIX'] || 'PVCGLUE'
     end
 
+    def self.project_file_name
+      File.join(self.application_dir, file_name)
+    end
+
+    def self.application_dir
+      Dir.pwd
+    end
 
     # silence Thor warnings, as these are not Thor commands.  (But we still need 'say' and 'ask' and friends.)
     no_commands do
 
       def initialize
-        #ENV["PVCGLUE_#{'application_name'.upcase}"] = 'override'
-        init(:cloud_manager) || configure_manager
-        raise(Thor::Error, "The manager has not been configured.  :(") if cloud_manager.nil?
+        if Pvcglue::Manager.local_mode?
+          init(:local_cloud_manager)
+          @cloud_manager = @local_cloud_manager
+        else
+          init(:cloud_manager) || configure_manager
+        end
+
+        # raise(Thor::Error, "The manager has not been configured.  :(") if cloud_manager.nil?
+        raise("The manager has not been configured.  :(") if cloud_manager.nil?
         init_except_manager
       end
 
       def init_except_manager
-        init(:cloud_name, 'cluster_one')
+        if Pvcglue::Manager.local_mode?
+          @cloud_name = 'local_cloud'
+        else
+          init(:cloud_name, 'cluster_one')
+        end
         init(:application_name, find_app_name)
       end
 
@@ -84,17 +102,31 @@ module Pvcglue
       end
 
       def project_file_name
-        File.join(application_dir, self.class.file_name)
+        self.class.project_file_name
       end
 
       def user_file_name
         File.join(Dir.home, self.class.file_name)
       end
 
+      # Thanks to http://stackoverflow.com/a/1509957/444774
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+            gsub(/([a-z\d])([A-Z])/, '\1_\2').
+            tr("-", "_").
+            downcase
+      end
+
       def find_app_name
-        # try rack file...anyone know a better way, without loading Rails?
+        # try known files...anyone know a better way, without loading Rails?
         rack_up = File.join(application_dir, 'config.ru')
-        $1.downcase if File.exists?(rack_up) && File.read(rack_up) =~ /^run (.*)::/
+        app_name = underscore($1) if File.exists?(rack_up) && File.read(rack_up) =~ /^run (.*)::/
+        unless app_name
+          file_name = File.join(application_dir, 'config', 'application.rb')
+          app_name = underscore($1) if File.exists?(file_name) && File.read(file_name) =~ /^module (.*)/
+        end
+        app_name
       end
 
       def options
@@ -118,7 +150,7 @@ module Pvcglue
       end
 
       def application_dir
-        Dir.pwd
+        self.class.application_dir
       end
 
       def app_maintenance_files_dir
@@ -126,7 +158,7 @@ module Pvcglue
       end
 
       def ruby_version_file_name
-        File.join(application_dir,'.ruby-version')
+        File.join(application_dir, '.ruby-version')
       end
 
       def ruby_version

data/lib/pvcglue/local.rb

@@ -0,0 +1,231 @@
+module Pvcglue
+  class Local
+    MACHINES = %w(manager lb web web_2 db memcached)
+
+    def self.vagrant(command)
+      raise(Thor::Error, "This command can only be used for the 'local' and 'test' stages.") unless Pvcglue.cloud.stage_name.in? %w(local test)
+      raise(Thor::Error, "Vagrant (www.vagrantup.com) does not appear to be installed.  :(") unless vagrant_available?
+      Bundler.with_clean_env { system("vagrant #{command}") }
+    end
+
+    def self.vagrant_available?
+      # puts Bundler.with_clean_env { `vagrant --version` }
+      Bundler.with_clean_env { `vagrant --version` } =~ /Vagrant \d+\.\d+\.\d+/
+    end
+
+    def self.start
+      if vagrant("up #{machines_in_stage}")
+        update_local_config(get_info_for_machines)
+      else
+        remove_cache_info_for_machines
+        raise(Thor::Error, "Error starting virtual machines.  :(")
+      end
+    end
+
+    def self.machines_in_stage
+      "/#{Pvcglue.cloud.stage_name}-\\|manager/" # must escape '|' for shell
+    end
+
+    def self.update_local_config_from_cache
+      data = File.read(cache_file_name)
+      machines = JSON.parse(data)
+      update_local_config(machines)
+    end
+
+    def self.update_local_config(machines)
+      machines = machines.with_indifferent_access
+      Pvcglue::Manager.set_local_mode
+      manager_file_name = Pvcglue::Configuration.project_file_name
+      data = File.exists?(manager_file_name) ? TOML.load_file(manager_file_name) : {}
+      # puts data.inspect
+      # puts machines.inspect
+      # puts machines[:manager][:public_ip].inspect
+      manager_ip = machines[:manager][:public_ip].to_s # to_s in case it's nil
+      raise(Thor::Error, "Manager IP is not valid. :(") unless manager_ip =~ /\b(?:\d{1,3}\.){3}\d{1,3}\b/
+      data["local_cloud_manager"] = manager_ip
+      # data["#{Pvcglue.cloud.stage_name}_cloud_manager"] = manager_ip
+      File.write(manager_file_name, TOML.dump(data.stringify_keys))
+
+      app_name = Pvcglue.configuration.application_name
+      data = {}
+      data = TOML.load_file(::Pvcglue.cloud.local_file_name) if File.exists?(::Pvcglue.cloud.local_file_name)
+      data = TOML.load_file(Pvcglue.configuration.cloud_cache_file_name) if data.empty? && File.exists?(Pvcglue.configuration.cloud_cache_file_name)
+      # TODO:  get repo_url from git, if possible
+      if data.empty?
+        data = {app_name =>
+                    {"excluded_db_tables" => ["versions"],
+                     "name" => app_name,
+                     "repo_url" => "git@github.com:talyric/pvcglue-dev-box.git", # TODO: get with git
+                     "ssh_allowed_from_all_port" => "22222",
+                     "swapfile_size" => 128,
+                     "time_zone" => "America/Los_Angeles",
+                     "authorized_keys" => {"example" => File.read(File.expand_path('~/.ssh/id_rsa.pub'))}, # TODO: error checking
+                     "dev_ip_addresses" => {"example" => "127.0.0.1"},
+                     "gems" => {"delayed_job" => false, "whenever" => false},
+                     "stages" =>
+                         {"local" =>
+                              {"db_rebuild" => true,
+                               "domains" => ["#{app_name}.local"],
+                               "ssl" => "none",
+                               "roles" =>
+                                   {"caching" =>
+                                        {"memcached" => {"private_ip" => "0.0.0.0", "public_ip" => "0.0.0.0"}},
+                                    "db" => {"db" => {"private_ip" => "0.0.0.0", "public_ip" => "0.0.0.0"}},
+                                    "lb" =>
+                                        {"lb" =>
+                                             {"allow_public_access" => true,
+                                              "private_ip" => "0.0.0.0",
+                                              "public_ip" => "0.0.0.0"}},
+                                    "web" => {"web_1" => {"private_ip" => "0.0.0.0", "public_ip" => "0.0.0.0"}}}},
+                          "test" =>
+                              {"db_rebuild" => false,
+                               "domains" => ["#{app_name}.test"],
+                               "ssl" => "none",
+                               "roles" =>
+                                   {"caching" =>
+                                        {"memcached" => {"private_ip" => "0.0.0.0", "public_ip" => "0.0.0.0"}},
+                                    "db" => {"db" => {"private_ip" => "0.0.0.0", "public_ip" => "0.0.0.0"}},
+                                    "lb" =>
+                                        {"lb" =>
+                                             {"allow_public_access" => true,
+                                              "private_ip" => "0.0.0.0",
+                                              "public_ip" => "0.0.0.0"}},
+                                    "web" =>
+                                        {"web_1" => {"private_ip" => "0.0.0.0", "public_ip" => "0.0.0.0"}}}}}}}
+      end
+      data = data.with_indifferent_access
+
+      # pp data
+      # pp machines
+      # puts "*"*80
+      # puts machines[:memcached][:public_ip].inspect
+      # puts "*"*80
+      # puts data[app_name].inspect
+      # puts "*"*80
+      # puts data[app_name][:stages].inspect
+      # puts "*"*80
+      # puts data[app_name][:stages][:local].inspect
+      # puts "*"*80
+      # puts data[app_name][:stages][:local][:roles].inspect
+      # puts "*"*80
+      # puts data[app_name][:stages][:local][:roles][:caching].inspect
+      # puts "*"*80
+      # puts data[app_name][:stages][:local][:roles][:caching][:memcached].inspect
+      # puts "*"*80
+      # puts data[app_name][:stages][:local][:roles][:caching][:memcached][:public_ip].inspect
+      # puts "*"*80
+      stage_name = Pvcglue.cloud.stage_name
+      data[app_name][:stages][stage_name][:roles][:caching][:memcached][:public_ip] = machines[:memcached][:public_ip]
+      data[app_name][:stages][stage_name][:roles][:caching][:memcached][:private_ip] = machines[:memcached][:private_ip]
+      data[app_name][:stages][stage_name][:roles][:db][:db][:public_ip] = machines[:db][:public_ip]
+      data[app_name][:stages][stage_name][:roles][:db][:db][:private_ip] = machines[:db][:private_ip]
+      data[app_name][:stages][stage_name][:roles][:lb][:lb][:public_ip] = machines[:lb][:public_ip]
+      data[app_name][:stages][stage_name][:roles][:lb][:lb][:private_ip] = machines[:lb][:private_ip]
+      data[app_name][:stages][stage_name][:roles][:web][:web_1][:public_ip] = machines[:web][:public_ip]
+      data[app_name][:stages][stage_name][:roles][:web][:web_1][:private_ip] = machines[:web][:private_ip]
+      # data[app_name][:stages][:local][:roles][:web][:web_2][:public_ip] = machines[:web_2][:public_ip]
+      # data[app_name][:stages][:local][:roles][:web][:web_2][:private_ip] = machines[:web_2][:private_ip]
+
+      Pvcglue.cloud.data = data
+      File.write(::Pvcglue.cloud.local_file_name, TOML.dump(Pvcglue.cloud.data))
+      File.write(Pvcglue.configuration.cloud_cache_file_name, TOML.dump(Pvcglue.cloud.data))
+    end
+
+    def self.stop
+      vagrant("halt #{machines_in_stage}")
+    end
+
+    def self.restart
+      vagrant("reload #{machines_in_stage}")
+    end
+
+    def self.rebuild
+      vagrant("destroy #{machines_in_stage} --force")
+      start
+    end
+
+    def self.destroy
+      vagrant("destroy #{machines_in_stage} --force")
+    end
+
+    def self.suspend
+      vagrant("suspend #{machines_in_stage}")
+    end
+
+    def self.kill
+      vagrant("halt #{machines_in_stage} --force")
+    end
+
+    def self.status
+      vagrant("status")
+    end
+
+    def self.remove_cache_info_for_machines
+      File.delete(cache_file_name)
+    end
+
+=begin
+1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default
+    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
+    inet 127.0.0.1/8 scope host lo
+       valid_lft forever preferred_lft forever
+    inet6 ::1/128 scope host
+       valid_lft forever preferred_lft forever
+2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
+    link/ether 08:00:27:e7:ab:02 brd ff:ff:ff:ff:ff:ff
+    inet 10.0.2.15/24 brd 10.0.2.255 scope global eth0
+       valid_lft forever preferred_lft forever
+    inet6 fe80::a00:27ff:fee7:ab02/64 scope link
+       valid_lft forever preferred_lft forever
+3: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
+    link/ether 08:00:27:8e:64:5a brd ff:ff:ff:ff:ff:ff
+    inet 10.10.10.208/24 brd 10.10.10.255 scope global eth1
+       valid_lft forever preferred_lft forever
+    inet6 fe80::a00:27ff:fe8e:645a/64 scope link
+       valid_lft forever preferred_lft forever
+4: eth2: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
+    link/ether 08:00:27:9a:14:92 brd ff:ff:ff:ff:ff:ff
+    inet 172.28.128.3/24 brd 172.28.128.255 scope global eth2
+       valid_lft forever preferred_lft forever
+    inet6 fe80::a00:27ff:fe9a:1492/64 scope link
+       valid_lft forever preferred_lft forever
+=end
+
+
+    def self.get_info_for_machines
+      machines = {}
+      MACHINES.each do |machine|
+        machines[machine] = {}
+        machine_name = machine == 'manager' ? machine : "#{Pvcglue.cloud.stage_name}-#{machine}"
+        puts "Getting networking info from #{machine_name}..."
+        data = `vagrant ssh #{machine_name} -c "ip a"`
+        puts data
+        data.scan(/inet (.*)\/.*global (eth[12])/) do |ip, eth|
+          type = eth == 'eth2' ? :private_ip : :public_ip
+          machines[machine][type] = ip
+        end
+        puts "Adding you public key to the root user for #{machine_name}..."
+        # cat ~/.ssh/id_rsa.pub | vagrant ssh manager -c 'sudo tee /root/.ssh/authorized_keys'
+        raise $? unless system %Q(cat ~/.ssh/id_rsa.pub | vagrant ssh #{machine_name} -c 'sudo tee /root/.ssh/authorized_keys')
+      end
+      FileUtils.mkdir_p(File.dirname(cache_file_name)) # the 'tmp' directory may not always exist
+      File.write(cache_file_name, machines.to_json)
+      machines
+    end
+
+    def self.cache_file_name
+      # TODO:  Remove caching, maybe?
+      File.join(Pvcglue::Configuration.application_dir, 'tmp', 'pvcglue-machines.json')
+    end
+  end
+
+
+  # def self.local
+  #   @local ||= Local.new
+  # end
+
+  # def self.local=(config)
+  #   @local = config
+  # end
+
+end

data/lib/pvcglue/manager.rb

@@ -75,9 +75,31 @@ module Pvcglue
       Pvcglue.configuration.configure_manager
     end
 
+    desc "mode", "set mode (default or local)"
+
+    def mode(mode = "default")
+      raise(Thor::Error, "invalid manager mode :(  (Hint:  try 'default' or 'local'.)") unless mode.in?(%w(default local))
+      if mode == 'default' && Pvcglue::Manager.local_mode?
+        Pvcglue::Manager.set_default_mode
+      elsif mode == 'local' && !Pvcglue::Manager.local_mode?
+        Pvcglue::Manager.set_local_mode
+      else
+        puts "The manager is already set to the #{mode} mode."
+      end
+    end
+
     # ------------------------------------------------------------------------------------------------------------------
 
+    def self.set_local_mode
+      File.write(Pvcglue::Manager.mode_file_name, %q(description = "The existence of this file sets the pvcglue manager mode to 'local'.  Use `pvc manager mode default` to reset."))
+    end
+
+    def self.set_default_mode
+      File.delete(Pvcglue::Manager.mode_file_name) if Pvcglue::Manager.local_mode?
+    end
+
     def self.initialize_cloud_data
+      # return if get_local_cloud_data
       unless read_cached_cloud_data
         Pvcglue::Packages.apply('manager-get-config'.to_sym, :manager, manager_node, 'pvcglue', 'manager')
         # Pvcglue::Packages.apply('manager-get-config'.to_sym, :manager, manager_node, 'pvcglue') # Can not use package as it causes infinite recursion, we'll just do it manually
@@ -94,6 +116,15 @@ module Pvcglue
       end
     end
 
+    # def self.get_local_cloud_data
+    #   return unless Pvcglue.cloud.stage_name.in? %w(local test)
+    #   puts "*"*80
+    #   puts Pvcglue.cloud.stage_name
+    #   puts "*"*80
+    #   raise(Thor::Error, "stopped.  :(")
+    #
+    # end
+
     def self.write_cloud_data_cache
       File.write(Pvcglue.configuration.cloud_cache_file_name, TOML.dump(Pvcglue.cloud.data))
     end
@@ -149,6 +180,14 @@ module Pvcglue
       clear_cloud_data_cache
     end
 
+    def self.local_mode?
+      File.exists?(Pvcglue::Manager.mode_file_name)
+    end
+
+    def self.mode_file_name
+      File.join(Pvcglue::Configuration.application_dir, '.pvcglue-manager-mode-local.toml')
+    end
+
   end
 
 end

data/lib/pvcglue/packages/rvm.rb

@@ -7,6 +7,7 @@ package 'rvm' do
   end
 
   apply do
+    run 'gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3'
     run '\curl -sSL https://get.rvm.io | bash -s stable'
     run "rvm requirements"
   end

data/lib/pvcglue/templates/database.yml.erb

@@ -55,3 +55,7 @@ preview:
 production:
   <<: *default_settings
   database: <%= Pvcglue.cloud.app_name + '_production' %>
+
+local:
+  <<: *default_settings
+  database: <%= Pvcglue.cloud.app_name + '_local' %>

data/lib/pvcglue/templates/deploy.rb.erb

@@ -9,6 +9,19 @@ set :linked_dirs, %w{log tmp/pids tmp/cache tmp/sockets}
 
 set :bundle_flags, '--deployment' # Remove the `--quiet` flag
 
+# Thanks to marinosbern!
+# From http://stackoverflow.com/a/22234123/444774
+desc 'Invoke a rake command on the remote server--Example usage: cap staging invoke[db:migrate]'
+task :invoke, [:command] => 'deploy:set_rails_env' do |task, args|
+  on primary(:app) do
+    within current_path do
+      with :rails_env => fetch(:rails_env) do
+        rake args[:command]
+      end
+    end
+  end
+end
+
 namespace :deploy do
 <% if Pvcglue.cloud.gems[:delayed_job] %>
   def args

data/lib/pvcglue/version.rb

@@ -1,3 +1,3 @@
 module Pvcglue
-  VERSION = "0.1.15"
+  VERSION = "0.1.17"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pvcglue
 version: !ruby/object:Gem::Version
-  version: 0.1.15
+  version: 0.1.17
 platform: ruby
 authors:
 - Andrew Lyric
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-17 00:00:00.000000000 Z
+date: 2015-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -228,6 +228,7 @@ files:
 - lib/pvcglue/db.rb
 - lib/pvcglue/deploy.rb
 - lib/pvcglue/env.rb
+- lib/pvcglue/local.rb
 - lib/pvcglue/manager.rb
 - lib/pvcglue/nodes.rb
 - lib/pvcglue/packages.rb