pvcglue 0.1.5

data/lib/pvcglue/configuration.rb

@@ -0,0 +1,157 @@
+require 'toml'
+# Inspired by http://robots.thoughtbot.com/mygem-configure-block
+# and https://github.com/thoughtbot/clearance/blob/master/lib/clearance/configuration.rb
+
+# Example for '~/.pvcglue.toml':
+#     cloud_manager = "nnn.nnn.nnn.nnn"
+
+module Pvcglue
+  class Configuration < Thor
+
+    attr_accessor :cloud_manager
+    attr_accessor :cloud_name
+    attr_accessor :application_name
+    attr_accessor :context
+
+    def self.file_name
+      ENV['PVCGLUE_FILE_NAME'] || '.pvcglue.toml'
+    end
+
+    def self.env_prefix
+      ENV['PVCGLUE_ENV_PREFIX'] || 'PVCGLUE'
+    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?
+        init_except_manager
+      end
+
+      def init_except_manager
+        init(:cloud_name, 'cluster_one')
+        init(:application_name, find_app_name)
+      end
+
+      def configure_manager
+        say('The manager has not been configured.')
+        manager = ask('What is the IP address or host name of the manager?')
+        default = !no?('Will this be the default manager? (Y/n)')
+        file_name = default ? user_file_name : project_file_name
+        File.write(file_name, %(cloud_manager = "#{manager}"\n))
+        say("Manager written to #{file_name}.")
+
+        @conf = nil # clear cache
+        init(:cloud_manager)
+        init_except_manager
+        clear_cloud_cache
+      end
+
+      def init(option, default=nil)
+        # ENV first, then pvcglue.toml (checking current working directory first, then in user home '~'), then default
+        # NOTE:  In the context of Rails, a standard initializer can also be used, and will override all settings here, but that should not really apply for 'pvcglue'
+        # /config/initializers/pvcglue.rb:
+        # Pvcglue.configure do |config|
+        #   config.cloud_manager = '192.168.0.1'
+        # end
+        value = ENV["#{self.class.env_prefix}_#{option.upcase}"] || get_conf(option) || default
+        #puts "Setting #{option}=#{value}"
+        instance_variable_set("@#{option}", value)
+      end
+
+      def merge_into_conf(file_name)
+        #puts "*"*80
+        #puts file_name
+        #puts File.exists?(file_name).inspect
+        if File.exists?(file_name)
+          data = TOML.load_file(file_name)
+          #puts data.inspect
+          @conf.merge!(data)
+        end
+      end
+
+      def get_conf(option)
+        unless @conf
+          @conf = {}
+          merge_into_conf(user_file_name)
+          merge_into_conf(project_file_name)
+        end
+        @conf[option.to_s]
+      end
+
+      def project_file_name
+        File.join(application_dir, self.class.file_name)
+      end
+
+      def user_file_name
+        File.join(Dir.home, self.class.file_name)
+      end
+
+      def find_app_name
+        # try rack file...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 (.*)::/
+      end
+
+      def options
+        Hash[instance_variables.map { |name| [name.to_s[1..-1].to_sym, instance_variable_get(name)] }].reject { |k| k == :conf }
+      end
+
+      def tmp_dir
+        File.join(application_dir, 'tmp')
+      end
+
+      def cloud_cache_file_name
+        # Just in case the Rails project hasn't yet been run, make sure the tmp
+        # dir exists.
+        Dir.mkdir(tmp_dir) unless Dir.exist?(tmp_dir)
+
+        File.join(tmp_dir, "pvcglue_#{cloud_manager}_#{cloud_name}_#{application_name}_cache.toml")
+      end
+
+      def clear_cloud_cache
+        File.delete(cloud_cache_file_name) if File.exists?(cloud_cache_file_name)
+      end
+
+      def application_dir
+        Dir.pwd
+      end
+
+      def app_maintenance_files_dir
+        File.join(application_dir, 'public', 'maintenance')
+      end
+
+      def ruby_version_file_name
+        File.join(application_dir,'.ruby-version')
+      end
+
+      def ruby_version
+        File.read(ruby_version_file_name).strip
+      end
+
+      def web_app_base_dir
+        '/sites'
+      end
+    end
+
+  end
+
+  # --------------------------------------------------------------------------------------------------------------------
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configuration=(config)
+    @configuration = config
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+end

data/lib/pvcglue/db.rb

@@ -0,0 +1,145 @@
+module Pvcglue
+  class Db < Thor
+
+    desc "config", "create/update database.yml"
+
+    def config
+      Pvcglue::Db.configure_database_yml
+    end
+
+    desc "push", "push"
+
+    def push(file_name = nil)
+      raise(Thor::Error, "Stage required.") if Pvcglue.cloud.stage_name.nil?
+      pg_restore(self.class.remote, file_name)
+    end
+
+    desc "pull", "pull"
+
+    def pull(file_name = nil)
+      raise(Thor::Error, "Stage required.") if Pvcglue.cloud.stage_name.nil?
+      pg_dump(self.class.remote, file_name)
+    end
+
+    desc "dump", "dump"
+
+    def dump(file_name = nil)
+      raise(Thor::Error, "Stage should not be set for this command.") unless Pvcglue.cloud.stage_name.nil?
+      pg_dump(self.class.local, file_name)
+    end
+
+    desc "restore", "restore"
+
+    def restore(file_name = nil)
+      raise(Thor::Error, "Stage should not be set for this command.") unless Pvcglue.cloud.stage_name.nil?
+      pg_restore(self.class.local, file_name)
+    end
+
+    desc "info", "info"
+
+    def info
+      if Pvcglue.cloud.stage_name
+        pp self.class.remote
+      else
+        pp self.class.local
+      end
+    end
+
+    # ------------------------------------------------------------------------------------------------------------------
+
+    def self.database_yml_file_name
+      File.join(Pvcglue::Capistrano.application_config_dir, 'database.yml')
+    end
+
+    class Db_Config < Struct.new(:host, :port, :database, :username, :password)
+    end
+
+    def self.local_info
+      @local_info ||= begin
+        template = Tilt::ERBTemplate.new('config/database.yml')
+        output = template.render
+        # puts output.inspect
+        info = YAML::load(output)
+        # puts info.inspect
+        info
+      end
+    end
+
+    def self.local
+      @local ||= begin
+        dev = local_info["development"]
+        Db_Config.new(dev["host"], dev["port"], dev["database"], dev["username"], dev["password"])
+      end
+    end
+
+    def self.remote
+      @remote ||= begin
+        Pvcglue::Env.initialize_stage_env
+        env = Pvcglue.cloud.stage_env
+        Db_Config.new(db_host_public,
+                      env["DB_USER_POSTGRES_PORT"],
+                      env["DB_USER_POSTGRES_DATABASE"],
+                      env["DB_USER_POSTGRES_USERNAME"],
+                      env["DB_USER_POSTGRES_PASSWORD"])
+      end
+    end
+
+    def self.db_host_public
+      node = Pvcglue.cloud.find_node('db')
+      node['db']['public_ip']
+    end
+
+
+    def self.file_helper(file_name)
+      # TODO:  make it more helpful ;)
+      stage = Pvcglue.cloud.stage_name || "dev"
+      file_name = "#{Pvcglue.configuration.application_name}_#{stage}_#{Time.now.strftime("%Y-%m-%d")}.dump" unless file_name
+      # "#{File.dirname(file_name)}/#{File.basename(file_name, '.*')}.dump"
+      file_name
+    end
+
+    def self.configure_database_yml
+      Pvcglue.render_template('database.yml.erb', Pvcglue::Db.database_yml_file_name)
+    end
+
+
+    # ------------------------------------------------------------------------------------------------------------------
+
+    # silence Thor warnings, as these are not Thor commands.  (But we still need 'say' and 'ask' and friends.)
+    no_commands do
+
+      def destroy_prod?
+        say("Are you *REALLY* sure you want to DESTROY the PRODUCTION database?")
+        input = ask("Type 'destroy production' if you are:")
+        raise(Thor::Error, "Ain't gonna do it.") if input.downcase != "destroy production"
+        puts "ok, going through with the it..."
+      end
+
+
+      def pg_dump(source, file_name)
+        cmd = "pg_dump -Fc --no-acl --no-owner -h #{source.host} -p #{source.port}"
+        cmd += " -U #{source.username}" if source.username
+        cmd += " #{source.database} -v -f #{self.class.file_helper(file_name)}"
+        puts cmd
+        unless system({"PGPASSWORD" => source.password}, cmd)
+          puts "ERROR:"
+          puts $?.inspect
+        end
+      end
+
+      def pg_restore(dest, file_name)
+        Pvcglue.cloud.stage_name == 'production' && destroy_prod?
+        cmd = "pg_restore --verbose --clean --no-acl --no-owner -h #{dest.host} -p #{dest.port}"
+        cmd += " -U #{dest.username}" if dest.username
+        cmd += " -d #{dest.database} #{self.class.file_helper(file_name)}"
+        puts cmd
+        unless system({"PGPASSWORD" => dest.password}, cmd)
+          puts "ERROR:"
+          puts $?.inspect
+        end
+      end
+    end
+
+  end
+
+end

data/lib/pvcglue/deploy.rb

@@ -0,0 +1,4 @@
+module Pvcglue
+  class Deploy
+  end
+end

data/lib/pvcglue/env.rb

@@ -0,0 +1,141 @@
+require 'pp'
+
+module Pvcglue
+  class Env < Thor
+
+    desc "push", "push"
+
+    def push
+      Pvcglue::Packages.apply('env-push'.to_sym, :manager, Pvcglue::Manager.manager_node, 'pvcglue')
+      self.class.clear_stage_env_cache
+      Pvcglue::Packages.apply('app-env-file'.to_sym, :env, Pvcglue.cloud.nodes_in_stage('web'))
+    end
+
+    desc "pull", "pull"
+
+    def pull
+      Pvcglue::Packages.apply('env-pull'.to_sym, :manager, Pvcglue::Manager.manager_node, 'pvcglue')
+      self.class.clear_stage_env_cache
+    end
+
+    desc "list", "list"
+
+    def list
+      self.class.initialize_stage_env
+      Pvcglue.cloud.stage_env.each { |key, value| puts "#{key}=#{value}" }
+    end
+
+    desc "default", "reset env to default.  Destructive!!!"
+
+    def default
+      if yes?("Are you sure?")
+        Pvcglue.cloud.stage_env = Pvcglue::Env.stage_env_defaults
+        Pvcglue::Env.save_stage_env
+      end
+    end
+
+    desc "set", "set environment variable(s) for the stage XYZ=123 [ZZZ=321]"
+
+    def set(*args)
+      self.class.initialize_stage_env
+      options = Hash[args.each.map { |l| l.chomp.split('=') }]
+      Pvcglue.cloud.stage_env.merge!(options)
+      self.class.save_stage_env
+      Pvcglue::Packages.apply('app-env-file'.to_sym, :env, Pvcglue.cloud.nodes_in_stage('web'))
+    end
+
+    desc "unset", "remove environment variable(s) for the stage XYZ [ZZZ]"
+
+    def unset(*args)
+      self.class.initialize_stage_env
+      args.each { |arg| puts "WARNING:  Key '#{arg}' not found." unless Pvcglue.cloud.stage_env.delete(arg) }
+      self.class.save_stage_env
+      Pvcglue::Packages.apply('app-env-file'.to_sym, :env, Pvcglue.cloud.nodes_in_stage('web'))
+    end
+
+    desc "rm", "alternative to unset"
+
+    def rm(*args)
+      unset(*args)
+    end
+
+
+    # ------------------------------------------------------------------------------------------------------------------
+
+    def self.initialize_stage_env
+      unless read_cached_stage_env
+        Pvcglue::Packages.apply('env-get-stage'.to_sym, :manager, Pvcglue::Manager.manager_node, 'pvcglue')
+        write_stage_env_cache
+      end
+      merged = stage_env_defaults.merge(Pvcglue.cloud.stage_env)
+      if merged != Pvcglue.cloud.stage_env
+        Pvcglue.cloud.stage_env = merged
+        save_stage_env
+      end
+    end
+
+    def self.save_stage_env
+      Pvcglue::Packages.apply('env-set-stage'.to_sym, :manager, Pvcglue::Manager.manager_node, 'pvcglue')
+      write_stage_env_cache
+    end
+
+    def self.stage_env_defaults
+      {
+          'RAILS_SECRET_TOKEN' => SecureRandom.hex(64),
+          'DB_USER_POSTGRES_HOST' => db_host,
+          'DB_USER_POSTGRES_PORT' => "5432",
+          'DB_USER_POSTGRES_USERNAME' => "#{Pvcglue.cloud.app_name}_#{Pvcglue.cloud.stage_name_validated}",
+          'DB_USER_POSTGRES_DATABASE' => "#{Pvcglue.cloud.app_name}_#{Pvcglue.cloud.stage_name_validated}",
+          'DB_USER_POSTGRES_PASSWORD' => new_password,
+          'MEMCACHE_SERVERS' => memcached_host
+      }
+    end
+
+    def self.db_host
+      node = Pvcglue.cloud.find_node('db')
+      node['db']['private_ip']
+    end
+
+    def self.memcached_host
+      node = Pvcglue.cloud.find_node('memcached')
+      "#{node['memcached']['private_ip']}:11211"
+    end
+
+    def self.new_password
+      "a#{SecureRandom.hex(16)}"
+    end
+
+    def self.write_stage_env_cache
+      File.write(stage_env_cache_file_name, TOML.dump(Pvcglue.cloud.stage_env))
+    end
+
+    def self.read_cached_stage_env
+      # TODO:  Only use cache in development of gem, do not cache by default, use Manager config
+      if File.exists?(stage_env_cache_file_name)
+        stage_env = File.read(stage_env_cache_file_name)
+        Pvcglue.cloud.stage_env = TOML.parse(stage_env)
+        return true
+      end
+      false
+    end
+
+    def self.stage_env_file_name
+      File.join(Pvcglue::Manager.manager_dir, stage_env_file_name_base)
+    end
+
+    def self.stage_env_file_name_base
+      @stage_env_file_name_base ||= "#{Pvcglue.configuration.cloud_name}_#{Pvcglue.configuration.application_name}_#{Pvcglue.cloud.stage_name_validated}.env.toml"
+    end
+
+    def self.stage_env_cache_file_name
+      File.join(Pvcglue.configuration.tmp_dir, "pvcglue_cache_#{stage_env_file_name_base}")
+    end
+
+    def self.clear_stage_env_cache
+      File.delete(stage_env_cache_file_name) if File.exists?(stage_env_cache_file_name)
+    end
+
+
+  end
+
+end