right_link 5.9.0

data/lib/gem_dependencies.rb

@@ -0,0 +1,83 @@
+# Copyright (c) 2011 RightScale Inc
+#
+# 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.
+
+# RVM pollutes the process environment with garbage that prevents us from activating sandboxed
+# RubyGems correctly. Unpollute the environment so our built-in RubyGems can setup the variables
+# appropriately for our own usage (and for installation of gems into the sandbox!)
+['GEM_HOME', 'GEM_PATH', 'IRBRC', 'MY_RUBY_HOME'].each { |key| ENV.delete(key) }
+
+require 'rubygems'
+
+# Note: can't use File#normalize_path (for Windows safety) yet because it's
+# defined by right_agent and gems haven't been activated yet.
+basedir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+Dir.chdir(basedir) do
+  if File.exist?('Gemfile')
+    # Development mode: activate Bundler gem, then let it setup our RubyGems
+    # environment for us -- but don't have it auto-require any gem files; we
+    # will do that ourselves.
+    require 'bundler'
+    Bundler.setup
+  else
+    # Release mode: use 'bare' RubyGems; assume that all gems were installed
+    # as system gems. Nothing to do here...
+    gem 'right_link'
+
+    gem 'eventmachine'
+
+    gem 'right_support'
+    gem 'right_amqp'
+    gem 'right_agent'
+    gem 'right_popen'
+    gem 'right_http_connection'
+    gem 'right_scraper'
+
+    gem 'ohai'
+    gem 'chef'
+
+    # Note: can't use RightScale::Platform because gem sources aren't loaded
+    if RUBY_PLATFORM =~ /mswin|mingw/
+      gem 'win32-api'
+      gem 'windows-api'
+      gem 'windows-pr'
+      gem 'win32-dir'
+      gem 'win32-eventlog'
+      gem 'ruby-wmi'
+      gem 'win32-process'
+      gem 'win32-pipe'
+      gem 'win32-open3'
+      gem 'win32-service'
+    end
+  end
+end
+
+# Make sure gem bin directories appear at the end of the PATH so our wrapper
+# scripts (e.g. those installed to /usr/bin) get top billing *iff* a bin dir
+# already appears on the PATH. Notice we choose regexp patterns that work under
+# both Linux and Windows.
+sep = (RUBY_PLATFORM =~ /mswin|mingw|dos/) ? ';' : ':'
+version = RUBY_VERSION.split('.')[0..1].join('.')
+subdir = /(ruby|gems)[\\\/]#{version}[\\\/]bin/
+paths = ENV['PATH'].split(sep)
+gem_bin = paths.select { |p| p =~ subdir }
+paths.delete_if { |p| p =~ subdir }
+ENV['PATH'] = (paths + gem_bin).join(sep)

data/lib/git_hooks/commit-msg.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# Disallow 'refs #' in right_link commits
+if IO.read(ARGV[0]) =~ /^(refs #|Refs #)\d+ /
+  puts 'Private ticket number reference.'
+  exit 1
+end

data/lib/instance/agent_config.rb

@@ -0,0 +1,168 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# 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.
+
+require 'rbconfig'
+
+module RightScale
+
+  # Extend AgentConfig for instance agents
+  AgentConfig.module_eval do
+
+    # Path to RightScale files in parent directory of right_link
+    def self.parent_dir
+      File.dirname(File.normalize_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'right_link')))
+    end
+
+     # @return [Array] an appropriate sequence of root directories for configuring the RightLink agent
+    def self.right_link_root_dirs
+      # RightLink certs are written at enrollment time, and live in the
+      # 'certs' subdir of the RightLink agent state dir.
+      os_root_dir  = File.join(AgentConfig.agent_state_dir)
+
+      # RightLink actors and the agent init directory are both packaged into the RightLink gem,
+      # as subdirectories of the gem base directory (siblings of 'lib' and 'bin' directories).
+      gem_root_dir = Gem.loaded_specs['right_link'].full_gem_path
+
+      [os_root_dir, gem_root_dir]
+    end
+
+    # Path to directory containing persistent RightLink agent state
+    def self.agent_state_dir
+      RightScale::Platform.filesystem.right_link_dynamic_state_dir
+    end
+
+    # Path to the file that contains the name of the cloud for this instance
+    def self.cloud_file_path
+      File.normalize_path(File.join(
+        RightScale::Platform.filesystem.right_scale_static_state_dir,
+        'cloud'))
+    end
+
+    # Path to directory containing transient cloud-related state (metadata, userdata, etc)
+    def self.cloud_state_dir
+      @cloud_state_dir ||= File.join(RightScale::Platform.filesystem.spool_dir, 'cloud')
+    end
+
+    # Set path to directory containing transient cloud-related state (metadata, userdata, etc)
+    def self.cloud_state_dir=(dir)
+      @cloud_state_dir = dir
+    end
+
+    # Path to directory for caching instance data
+    def self.cache_dir
+      @cache_dir ||= File.join(RightScale::Platform.filesystem.cache_dir, 'rightscale')
+    end
+
+    # Set path to directory for caching instance data
+    def self.cache_dir=(dir)
+      @cache_dir = dir
+    end
+
+    # Path to directory for Ruby source code, e.g. cookbooks
+    def self.source_code_dir
+      @source_code_dir ||= File.join(RightScale::Platform.filesystem.source_code_dir, 'rightscale')
+    end
+
+    # Set path to directory for Ruby source code, e.g. cookbooks
+    def self.source_code_dir=(dir)
+      @source_code_dir = dir
+    end
+
+    # Path to downloaded cookbooks directory
+    def self.cookbook_download_dir
+      @cookbook_download_dir ||= File.join(cache_dir, 'cookbooks')
+    end
+
+    # Path to SCM repository checkouts that contain development cookbooks
+    def self.dev_cookbook_checkout_dir
+      @dev_cookbook_dir ||= File.join(source_code_dir, 'cookbooks')
+    end
+
+    # Path to RightScript recipes cookbook directory
+    def self.right_scripts_repo_dir
+      @right_scripts_repo_dir ||= File.join(cache_dir, 'right_scripts')
+    end
+
+    # Maximum number of times agent should retry installing packages
+    def self.max_packages_install_retries
+      3
+    end
+
+    # Path to directory for sandbox if it exists
+    def self.ruby_dir
+      ( ENV['RS_RUBY_EXE'] && File.dirname(ENV['RS_RUBY_EXE']) ) ||
+        Config::CONFIG["bindir"]
+    end
+
+    # Ruby command
+    def self.ruby_cmd
+      # Allow test environment to specify a non-program files location for tools
+      ENV['RS_RUBY_EXE'] ||
+        File.join( ruby_dir,
+                   Config::CONFIG["RUBY_INSTALL_NAME"] + Config::CONFIG["EXEEXT"] )
+    end
+
+    # Sandbox gem command
+    def self.gem_cmd
+      if RightScale::Platform.windows?
+        # Allow test environment to specify a non-program files location for tools
+        if ENV['RS_GEM']
+          ENV['RS_GEM']
+        elsif dir = ruby_dir
+          "\"#{ruby_cmd}\" \"#{File.join(dir, 'gem.exe')}\""
+        else
+          'gem'
+        end
+      else
+        if dir = ruby_dir
+          File.join(dir, 'gem')
+        else
+          # Development setup
+          `which gem`.chomp
+        end
+      end
+    end
+
+    # Sandbox git command
+    def self.git_cmd
+      if RightScale::Platform.windows?
+        # Allow test environment to specify a non-program files location for tools
+        if ENV['RS_GIT_EXE']
+          ENV['RS_GIT_EXE']
+        elsif dir = ruby_dir
+          File.normalize_path(File.join(dir, '..', '..', 'bin', 'windows', 'git.cmd'))
+        else
+          'git'
+        end
+      else
+        if dir = ruby_dir
+          File.join(dir, 'git')
+        else
+          # Development setup
+          `which git`.chomp
+        end
+      end
+    end
+
+  end # AgentConfig
+
+end # RightScale

data/lib/instance/agent_watcher.rb

@@ -0,0 +1,233 @@
+# === Synopsis:
+#   RightScale Agent Watcher
+#
+#   Agent monitoring intelligence. Will watch a given list of agents for
+#   unexpected termination and react accordingly. This can be either simply
+#   logging to a given IO stream, restarting the agent or yielding to any
+#   arbitrary block passed in during initialization.
+#
+# Copyright (c) 2013 RightScale Inc
+#
+# 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.
+#
+
+require 'rubygems'
+require 'right_agent/pid_file'
+require 'thread'
+
+module RightScale 
+
+  class AgentWatcher
+    class AlreadyWatched < Exception; end
+    class UnknownAgent < Exception; end
+
+    # Some Time calculation constants
+    # ===
+    SECOND = 1
+    MINUTE = 60 * SECOND
+    HOUR = 60 * MINUTE
+    DAY = 24 * HOUR
+    # ===
+
+    DEFAULT_FREQUENCY_CHECK = 5 * SECOND
+
+    def initialize(logger, pid_dir=nil)
+      @logger = logger
+      @pid_dir = pid_dir
+      @running = false
+      @stopped_list = {}
+      @watched_list = {}
+      @watch_list_lock = Monitor.new
+    end
+
+    def log_info(s)
+      @logger.call("AgentWatcher: #{s}")
+    end
+
+    def kill_agent(identity, signal='SIGKILL')
+      @watch_list_lock.synchronize do
+        raise UnknownAgent("#{identity} is not a known agent.") unless @watched_list.has_key?(identity)
+        agent = @watched_list.delete(identity)
+        Process.kill(signal, agent[:pid].read_pid[:pid])
+        @stopped_list[identity] = agent
+      end
+    end
+
+    def restart_agent(identity)
+      stop_agent(identity)
+      start_agent(identity)
+    end
+
+    def start_watching()
+      return if @running
+      # This logic is implemented with a priority queue of "next check" times:
+      #
+      # This allows us not to have to start a bunch of timers and do time
+      # alrithmatic which can be tricky when someone goes and changes the date
+      # on the system this code is running.
+
+      # Initialize all agents
+      @watch_list_lock.synchronize {
+        @watched_list.each { |k, v| v[:next_check] = 0 }
+      }
+
+      log_info("Starting the AgentWatcher.")
+      @agent_watcher_thread = Thread.new do
+        @running = true
+        while @running
+          next_check = 0
+          time_start = Time.now
+
+          # TODO: This may need to be refactored into a real priority queue if we
+          # start to have large amounts of agents assigned, rather than incur the
+          # overhead of discovering the next smallest number every iteration. -brs
+          @watch_list_lock.synchronize do
+            # No use doing anything till we have something to work on, I would have
+            # rather used a ConditionVariable here, but they are not compatible with
+            # Monitor objects, and I need reentrance.
+            sleep DEFAULT_FREQUENCY_CHECK until @watched_list.size > 0 or not @running
+
+            # Check all processes in the list with a next check time of zero
+            # replacing the next check time with their frequency.
+            @watched_list.each do |k,v|
+              if v[:next_check] <= 0
+                v[:next_check] = v[:freq]
+                check_agent(k)
+              end
+            end
+
+            # Find the lowest next check
+            @watched_list.each do |k,v|
+              next_check = v[:next_check] unless (next_check > 0 and next_check < v[:next_check])
+            end
+
+            # Subtract this from all the elements before we sleep
+            @watched_list.each do |k,v| 
+              v[:next_check] -= next_check
+            end
+          end
+
+          # Account for the time it took to check agents and find the next
+          # check time.
+          next_check -= (Time.now - time_start).to_i
+
+          # Sleep for the next check time
+          next_check -= sleep(next_check) while (next_check > 0 and @running)
+        end
+        log_info("Shutting down.")
+      end
+    end
+
+    def start_agent(identity)
+      @watch_list_lock.synchronize {
+        raise UnknownAgent("#{identity} is not a known stopped agent.") unless @stopped_list.has_key?(identity)
+        agent = @stopped_list.delete(identity)
+        agent[:pid].remove
+        system("#{agent[:exec]} #{agent[:start_opts]}")
+        log_info("Successfully started the #{identity} agent.")
+        # Give us some time to come up before the next check...should be good in
+        # 60 seconds I would think.
+        agent[:next_check] = MINUTE
+        @watched_list[identity] = agent
+      }
+    end
+
+    def stop_watching()
+      return unless @running
+      log_info("Stopping the AgentWatcher.")
+      @running = false
+      @agent_watcher_thread.terminate
+      @agent_watcher_thread.join
+      @agent_watcher_thread = nil
+      log_info("AgentWatcher Stopped.")
+    end
+
+    def stop_agent(identity)
+      @watch_list_lock.synchronize {
+        raise UnknownAgent("#{identity} is not a known agent.") unless @watched_list.has_key?(identity)
+        agent = @watched_list.delete(identity)
+        if system("#{agent[:exec]} #{agent[:stop_opts]}")
+          log_info("Successfully stopped the #{identity} agent.")
+          agent[:pid].remove
+        end
+        @stopped_list[identity] = agent
+      }
+    end
+
+    def watch_agent(identity, exec, start_opts, stop_opts, freq=DEFAULT_FREQUENCY_CHECK)
+      # Make things simple for now and require a resolution of 1 second
+      # for the frequency check.
+      raise BadFrequency.new unless (freq > 1)
+
+      # Protect the watch list from the thread monitoring the agents
+      @watch_list_lock.synchronize {
+        unless @watched_list.has_key?(identity)
+
+          # If we were given a block, use that for state change, otherwise restart
+          action = (block_given? && Proc.new) || Proc.new do |identity, state, mesg|
+            if state == :stopped
+              log_info("#{identity} has stopped, restarting now.")
+              self.start_agent(identity)
+            end
+          end
+
+          @watched_list[identity] = {
+            :action=>action,
+            :exec=>exec,
+            :start_opts=>start_opts,
+            :stop_opts=>stop_opts,
+            :freq=>freq,
+            :pid=>PidFile.new(identity,@pid_dir),
+          }
+        else
+          raise AlreadyWatched.new("The agent [#{identity}] is already being watched by us.")
+        end
+      }
+    end
+
+    private
+
+    def agent_running?(identity)
+      # The check method really tells us if the agent ISN'T running
+      # and throws an exception if it is...poorly named I know
+      @watch_list_lock.synchronize do
+        begin
+          @watched_list[identity][:pid].check
+          false
+        rescue PidFile::AlreadyRunning
+          true
+        end
+      end
+    end
+
+    def check_agent(identity)
+      @watch_list_lock.synchronize do
+        test_agent = agent_running?(identity)
+        unless test_agent
+          agent = @watched_list.delete(identity)
+          @stopped_list[identity] = agent
+          agent[:action].call(identity, :stopped, "The #{identity} agent does not appear to be running!")
+        end
+      end
+    end
+
+  end
+
+end

data/lib/instance/audit_cook_stub.rb

@@ -0,0 +1,104 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# 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.
+
+
+module RightScale
+
+  # This class acts as a recipient of audit requests sent by the cook
+  # process.
+  # The audit proxy which will forward the audits to the core should be
+  # initialized before each invocation to cook
+  class AuditCookStub
+
+    include RightSupport::Ruby::EasySingleton
+
+    def initialize
+      @auditors = {}
+      @close_callbacks = {}
+    end
+
+    # Sets up the audit proxy that should be used to forward all audit commands.
+    #
+    # === Parameters
+    # thread_name(String):: execution thread name or default
+    # auditor(AuditProxy):: audit proxy
+    def setup_audit_forwarding(thread_name, auditor)
+      @auditors ||= {}
+      @auditors[thread_name] = auditor
+    end
+
+    # Forward audit command received from cook using audit proxy
+    #
+    # === Parameters
+    # kind(Symbol):: Kind of audit, one of :append_info, :append_error, :create_new_section, :update_status and :append_output
+    # text(String):: Audit content
+    # thread_name(String):: thread name for audit or default
+    # options[:category]:: Optional, associated event category, one of RightScale::EventCategories
+    #
+    # === Raise
+    # RuntimeError:: If audit_proxy is not set prior to calling this
+    def forward_audit(kind, text, thread_name, options)
+      auditor = @auditors[thread_name]
+      return unless auditor
+      if kind == :append_output
+        auditor.append_output(text)
+      else
+        auditor.__send__(kind, text, options)
+      end
+    end
+
+    # Register listener for when audit proxy is closed/reset
+    # Listener is executable sequence proxy to synchronize betweek
+    # cook process going away and all audits having been processed
+    #
+    # === Parameters
+    # thread_name(String):: execution thread name or default
+    #
+    # === Block
+    # Given block should not take any argument and gets called back when proxy is reset
+    #
+    # === Return
+    # true:: Always return true
+    def on_close(thread_name, &blk)
+      @close_callbacks[thread_name] = blk
+      true
+    end
+
+    # Reset proxy object and notify close event listener
+    #
+    # === Parameters
+    # thread_name(String):: execution thread name or default
+    #
+    # === Return
+    # true:: Always return true
+    def close(thread_name)
+      close_callback = @close_callbacks[thread_name]
+      close_callback.call if close_callback
+      true
+    ensure
+      @auditors[thread_name] = nil
+      @close_callbacks[thread_name] = nil
+    end
+
+  end
+
+end