bosh_agent 1.5.0.pre.1113

data/lib/bosh_agent/platform/linux/network.rb

@@ -0,0 +1,124 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Platform::Linux::Network
+
+    def initialize(template_dir)
+      @template_dir   = template_dir
+      @config         = Bosh::Agent::Config
+      @infrastructure = @config.infrastructure
+      @logger         = @config.logger
+      @networks       = []
+      @dns            = []
+    end
+
+    def setup_networking
+      case @config.infrastructure_name
+        when "vsphere"
+          setup_networking_from_settings
+        when "aws"
+          setup_dhcp_from_settings
+        when "openstack"
+          setup_dhcp_from_settings
+        else
+          raise Bosh::Agent::FatalError, "Setup networking failed, unsupported infrastructure #{Bosh::Agent::Config.infrastructure_name}"
+      end
+    end
+
+
+    def setup_networking_from_settings
+      mac_addresses = detect_mac_addresses
+
+      networks.values.each do |v|
+        mac = v["mac"]
+
+        unless mac_addresses.has_key?(mac)
+          raise Bosh::Agent::FatalError, "#{mac} from settings not present in instance"
+        end
+
+        v["interface"] = mac_addresses[mac]
+
+        begin
+          net_cidr = NetAddr::CIDR.create("#{v['ip']} #{v['netmask']}")
+          v["network"] = net_cidr.network
+          v["broadcast"] = net_cidr.broadcast
+        rescue NetAddr::ValidationError => e
+          raise Bosh::Agent::FatalError, e.to_s
+        end
+      end
+
+      write_network_interfaces
+      write_resolv_conf
+      gratuitous_arp
+    end
+
+    def setup_dhcp_from_settings
+      unless dns.empty?
+        write_dhcp_conf
+      end
+    end
+
+    def dns
+      default_dns_network = networks.values.detect do |settings|
+        settings.fetch('default', []).include?('dns') && settings["dns"]
+      end
+      default_dns_network ? default_dns_network["dns"] : []
+    end
+
+    private
+
+    def networks
+      @config.settings["networks"]
+    end
+
+    def detect_mac_addresses
+      mac_addresses = {}
+      Dir['/sys/class/net/*'].each do |dev_path|
+        dev = File.basename(dev_path)
+        mac = File.read(File.join(dev_path, 'address')).strip
+        mac_addresses[mac] = dev
+      end
+      mac_addresses
+    end
+
+    def write_resolv_conf
+      template = ERB.new("<% dns.each do |server| %>\nnameserver <%= server %>\n<% end %>\n", 0, '%<>')
+      result = template.result(binding)
+      Bosh::Agent::Util::update_file(result, '/etc/resolv.conf')
+    end
+
+    def gratuitous_arp
+      # HACK to send a gratuitous arp every 10 seconds for the first minute
+      # after networking has been reconfigured.
+      Thread.new do
+        6.times do
+          @networks.each do |name, network|
+            until File.exist?("/sys/class/net/#{network['interface']}")
+              sleep 0.1
+            end
+
+            arp_cmd = "arping -c 1 -U -I #{network['interface']} #{network['ip']}"
+            @logger.info(arp_cmd)
+            Bosh::Exec.sh "#{arp_cmd}"
+          end
+          sleep 10
+        end
+      end
+    end
+
+    def write_network_interfaces
+      raise Bosh::Agent::UnimplementedMethod.new
+    end
+
+    def write_dhcp_conf
+      raise Bosh::Agent::UnimplementedMethod.new
+    end
+
+    def load_erb(file)
+      path = File.expand_path(file, @template_dir)
+      File.open(path) do |f|
+        f.read
+      end
+    end
+  end
+end

data/lib/bosh_agent/platform/linux/password.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Platform::Linux::Password
+    USERS = ['root', Bosh::Agent::BOSH_APP_USER]
+
+    # Update passwords
+    def update(settings)
+      password = settings.fetch('env', {}).fetch('bosh', {})['password']
+
+      if password
+        USERS.each { |user| update_password(user, password) }
+      end
+    end
+
+    protected
+    # Actually update password
+    def update_password(user, encrypted_password)
+      Bosh::Exec.sh "usermod -p '#{encrypted_password}' #{user} 2>%"
+    end
+  end
+end

data/lib/bosh_agent/platform/linux.rb

@@ -0,0 +1,4 @@
+module Bosh::Agent
+  module Platform::Linux
+  end
+end

data/lib/bosh_agent/platform/ubuntu/network.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Platform::Ubuntu::Network < Platform::Linux::Network
+    include Bosh::Exec
+
+    def initialize(template_dir)
+      super
+    end
+
+    def write_network_interfaces
+      template = ERB.new(load_erb("interfaces.erb"), 0, '%<>-')
+      result = template.result(binding)
+      network_updated = Bosh::Agent::Util::update_file(result, '/etc/network/interfaces')
+      if network_updated
+        @logger.info("Updated networking")
+        restart_networking_service
+      end
+    end
+
+    def restart_networking_service
+      # ubuntu 10.04 networking startup/upstart stuff is quite borked
+      networks.each do |k, v|
+        interface = v['interface']
+        @logger.info("Restarting #{interface}")
+        output = sh("service network-interface stop INTERFACE=#{interface}").output
+        output += sh("service network-interface start INTERFACE=#{interface}").output
+        @logger.info("Restarted networking: #{output}")
+      end
+    end
+
+    def write_dhcp_conf
+      template = ERB.new(load_erb("dhclient_conf.erb"), 0, '%<>-')
+      result = template.result(binding)
+      updated = Bosh::Agent::Util::update_file(result, '/etc/dhcp3/dhclient.conf')
+      if updated
+        @logger.info("Updated dhclient.conf")
+        restart_dhclient
+      end
+    end
+
+    # Executing /sbin/dhclient starts another dhclient process, so it'll cause
+    # a conflict with the existing system dhclient process and dns changes will
+    # be flip floping each lease time. So in order to refresh dhclient
+    # configuration we need to restart networking.
+    #
+    # If dhclient3 cannot release a lease because it collides with a network
+    # restart (message "receive_packet failed on eth0: Network is down"
+    # appears at /var/log/syslog) then the old dhclient3 process won't be
+    # killed (see bug LP #38140), and there will be two dhclient3 process
+    # running (and dns changes will be flip floping each lease time). So
+    # before restarting the network, we first kill all dhclient3 process.
+    def restart_dhclient
+      sh("pkill dhclient3", :on_error => :return)
+      sh("/etc/init.d/networking restart", :on_error => :return)
+    end
+
+  end
+end

data/lib/bosh_agent/platform/ubuntu/templates/dhclient_conf.erb

@@ -0,0 +1,56 @@
+# Configuration file for /sbin/dhclient, which is included in Debian's
+# dhcp3-client package.
+#
+# This is a sample configuration file for dhclient. See dhclient.conf's
+# man page for more information about the syntax of this file
+# and a more comprehensive list of the parameters understood by
+# dhclient.
+#
+# Normally, if the DHCP server provides reasonable information and does
+# not leave anything out (like the domain name, for example), then
+# few changes must be made to this file, if any.
+#
+
+option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
+
+send host-name "<hostname>";
+#send dhcp-client-identifier 1:0:a0:24:ab:fb:9c;
+#send dhcp-lease-time 3600;
+#supersede domain-name "fugue.com home.vix.com";
+request subnet-mask, broadcast-address, time-offset, routers,
+  domain-name, domain-name-servers, domain-search, host-name,
+  netbios-name-servers, netbios-scope, interface-mtu,
+  rfc3442-classless-static-routes, ntp-servers;
+<% dns.reverse.each do |server| -%>
+prepend domain-name-servers <%= server %>;
+<% end -%>
+
+#require subnet-mask, domain-name-servers;
+#timeout 60;
+#retry 60;
+#reboot 10;
+#select-timeout 5;
+#initial-interval 2;
+#script "/etc/dhcp3/dhclient-script";
+#media "-link0 -link1 -link2", "link0 link1";
+#reject 192.33.137.209;
+
+#alias {
+#  interface "eth0";
+#  fixed-address 192.5.5.213;
+#  option subnet-mask 255.255.255.255;
+#}
+
+#lease {
+#  interface "eth0";
+#  fixed-address 192.33.137.200;
+#  medium "link0 link1";
+#  option host-name "andare.swiftmedia.com";
+#  option subnet-mask 255.255.255.0;
+#  option broadcast-address 192.33.137.255;
+#  option routers 192.33.137.250;
+#  option domain-name-servers 127.0.0.1;
+#  renew 2 2000/1/12 00:00:01;
+#  rebind 2 2000/1/12 00:00:01;
+#  expire 2 2000/1/12 00:00:01;
+#}

data/lib/bosh_agent/platform/ubuntu/templates/interfaces.erb

@@ -0,0 +1,14 @@
+auto lo
+iface lo inet loopback
+
+<% networks.each do |name, n| -%>
+auto <%= n["interface"] %>
+iface <%= n["interface"] %> inet static
+    address <%= n["ip"]%>
+    network <%= n["network"] %>
+    netmask <%= n["netmask"]%>
+    broadcast <%= n["broadcast"] %>
+<% if n.key?('default') && n['default'].include?('gateway') -%>
+    gateway <%= n["gateway"] %>
+<% end %>
+<% end -%>

data/lib/bosh_agent/platform/ubuntu/templates/logrotate.erb

@@ -0,0 +1,8 @@
+<%= base_dir %>/data/sys/log/*.log <%= base_dir %>/data/sys/log/*/*.log <%= base_dir %>/data/sys/log/*/*/*.log {
+  missingok
+  rotate 7
+  compress
+  delaycompress
+  copytruncate
+  size=<%= size %>
+}

data/lib/bosh_agent/platform/ubuntu.rb

@@ -0,0 +1,4 @@
+module Bosh::Agent
+  module Platform::Ubuntu
+  end
+end

data/lib/bosh_agent/platform.rb

@@ -0,0 +1,26 @@
+module Bosh::Agent
+  class UnknownPlatform < StandardError;
+  end
+
+  module Platform
+    def self.platform(platform_name)
+      case platform_name
+        when 'ubuntu'
+          template_dir = File.expand_path(File.join(File.dirname(__FILE__), 'platform/ubuntu/templates'))
+          Platform::Linux::Adapter.new(Platform::Linux::Disk.new,
+                                       Platform::Linux::Logrotate.new(template_dir),
+                                       Platform::Linux::Password.new,
+                                       Platform::Ubuntu::Network.new(template_dir))
+
+        when 'centos'
+          template_dir = File.expand_path(File.join(File.dirname(__FILE__), 'platform/centos/templates'))
+          Platform::Linux::Adapter.new(Platform::Centos::Disk.new,
+                                       Platform::Linux::Logrotate.new(template_dir),
+                                       Platform::Linux::Password.new,
+                                       Platform::Centos::Network.new(template_dir))
+        else
+          raise UnknownPlatform, "platform '#{platform_name}' not found"
+      end
+    end
+  end
+end

data/lib/bosh_agent/remote_exception.rb

@@ -0,0 +1,62 @@
+module Bosh::Agent
+
+  # Helper class to pass around and fromat exceptions in the agent
+  # to the director
+  class RemoteException
+    attr_reader :message, :backtrace, :blob
+
+    def initialize(message, backtrace=nil, blob=nil)
+      @message = message
+      @backtrace = backtrace.nil? ? caller : backtrace
+      @blob = blob
+    end
+
+    # Stores the blob in the configured blobstore
+    #
+    # @return [String] blobstore id of the stored object, or an error
+    # string which can be displayed instead of the blob
+    def store_blob
+      bsc_options  = Bosh::Agent::Config.blobstore_options
+      bsc_provider = Bosh::Agent::Config.blobstore_provider
+
+      blobstore = Bosh::Blobstore::Client.create(bsc_provider, bsc_options)
+
+      logger.info("Uploading blob for '#{@message}' to blobstore")
+
+      blobstore_id = nil
+      blobstore_id = blobstore.create(@blob)
+
+      blobstore_id
+    rescue Bosh::Blobstore::BlobstoreError => e
+      logger.warn("unable to upload blob for '#{@message}'")
+      "error: unable to upload blob to blobstore: #{e.message}"
+    end
+
+    # Returns a hash of the [RemoteException] suitable to convert to json
+    #
+    # @return [Hash] [RemoteException] represented as a [Hash]
+    def to_hash
+      hash = {:message => @message}
+      hash[:backtrace] = @backtrace
+      hash[:blobstore_id] = store_blob if @blob
+      {:exception => hash}
+    end
+
+    def logger
+      Bosh::Agent::Config.logger
+    end
+
+    # Helper class method that creates a [Bosh::Agent::RemoteException]
+    # from an [Exception]
+    #
+    # @return [Bosh::Agent::RemoteException]
+    def self.from(exception)
+      blob = nil
+      if exception.instance_of?(Bosh::Agent::MessageHandlerError)
+        blob = exception.blob
+      end
+      self.new(exception.message, exception.backtrace, blob)
+    end
+
+  end
+end

data/lib/bosh_agent/runner.rb

@@ -0,0 +1,36 @@
+module Bosh::Agent
+  class Runner
+    def self.run(options)
+      Config.setup(options)
+      Runner.new.start
+    end
+
+    def initialize
+      @logger = Config.logger
+    end
+
+    def start
+      $stdout.sync = true
+      @logger.info("Starting agent #{VERSION}...")
+
+      if Config.configure
+        @logger.info('Configuring agent...')
+        Bootstrap.new.configure
+
+        Monit.enable
+        Monit.start
+        Monit.start_services
+      else
+        @logger.info("Skipping configuration step (use '-c' argument to configure on start) ")
+      end
+
+      if Config.mbus.start_with?('https')
+        @logger.info('Starting up https agent')
+        require 'bosh_agent/http_handler'
+        HTTPHandler.start
+      else
+        Handler.start
+      end
+    end
+  end
+end

data/lib/bosh_agent/settings.rb

@@ -0,0 +1,61 @@
+require 'forwardable'
+
+module Bosh::Agent
+  class Settings
+    extend Forwardable
+
+    def_delegators :@settings, :fetch, :[]
+
+    # Loads settings specific to the current infrastructure, and then caches
+    # the result to disk. If it can't fetch settings, it will fall back to
+    # previously cached settings
+    def self.load(cache_path=nil)
+      settings = new(cache_path || Config.settings_file)
+      settings.load
+      settings.cache
+      settings
+    end
+
+    def initialize(file)
+      @settings = {}
+      @cache_file = file
+    end
+
+    def load
+      load_from_infrastructure
+      cache
+    rescue LoadSettingsError => e
+      logger.info("failed to load infrastructure settings: #{e.message}")
+      load_from_cache
+    end
+
+    def cache
+      json = Yajl::Encoder.encode(@settings)
+      File.open(@cache_file, 'w') do |file|
+        file.write(json)
+      end
+    end
+
+    private
+
+    def load_from_infrastructure
+      @settings = Bosh::Agent::Config.infrastructure.load_settings
+      logger.info("loaded new infrastructure settings: #{@settings.inspect}")
+    end
+
+    def load_from_cache
+      json = File.read(@cache_file)
+      # perhaps catch json parser errors too and raise as LoadSettingsSerror?
+      @settings = Yajl::Parser.new.parse(json)
+      logger.info("loaded cached settings: #{@settings.inspect}")
+    rescue Errno::ENOENT
+      raise LoadSettingsError, "could neither load infrastructure settings " \
+        "nor cached settings from: #@cache_file"
+    end
+
+    def logger
+      Bosh::Agent::Config.logger
+    end
+
+  end
+end

data/lib/bosh_agent/sigar_box.rb

@@ -0,0 +1,26 @@
+module Bosh
+  module Agent
+    class NullLogger < Logger
+      def initialize
+      end
+
+      def add(level, message)
+        # do nothing
+      end
+    end
+
+    class SigarBox
+      def self.create_sigar
+        sigar = nil
+        begin
+          GC.disable
+          sigar = Sigar.new
+          sigar.logger = NullLogger.new
+        ensure
+          GC.enable
+        end
+        sigar
+      end
+    end
+  end
+end

data/lib/bosh_agent/smtp_server.rb

@@ -0,0 +1,96 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+
+  class SmtpServer < EM::Protocols::SmtpServer
+
+    class Error < StandardError; end
+
+    MAX_MESSAGE_SIZE   = 1024 * 1024 # 1M
+    INACTIVITY_TIMEOUT = 10 # seconds
+
+    def initialize(*args)
+      super
+
+      options = args.last
+
+      @logger        = Config.logger
+      @user          = options[:user]
+      @password      = options[:password]
+      @processor     = options[:processor]
+      @authenticated = false
+      @chunks        = [ ]
+      @msg_size      = 0
+
+      # @parms come from EM:Protocols::SmtpServer
+      @parms[:auth] = true if @user && @password
+
+      self.comm_inactivity_timeout = INACTIVITY_TIMEOUT
+    end
+
+    def get_server_greeting
+      "BOSH Agent SMTP Server"
+    end
+
+    def get_server_domain
+      get_server_greeting
+    end
+
+    def authenticated?
+      @authenticated
+    end
+
+    # We don't really care about senders and recipients
+    # as we only use SMTP for data transport between
+    # Monit and Agent. However it's handy to use
+    # the SMTP sequence constraints to enforce that
+    # only authenticated user can actually send data.
+
+    def receive_plain_auth(user, password)
+      @authenticated = (user == @user && @password == password)
+    end
+
+    # Only accept MAIL FROM if already authenticated
+    def receive_sender(sender)
+      authenticated?
+    end
+
+    # Only accept RCPT TO if already authenticated
+    def receive_recipient(rcpt)
+      authenticated?
+    end
+
+    def receive_data_chunk(c)
+      @msg_size += c.join.length
+
+      if @msg_size > MAX_MESSAGE_SIZE
+        send_data "552 Message too large\r\n"
+        close_connection_after_writing
+      else
+        @chunks += c
+      end
+    end
+
+    def receive_message
+      unless @processor
+        @logger.error "Failed to process alert: no alert processor provided"
+        return false
+      end
+
+      unless @processor.respond_to?(:process_email_alert)
+        @logger.error "Failed to process alert: alert processor should respond to :process_email_alert method"
+        return false
+      end
+
+      message = @chunks.join("\n")
+      @chunks = [ ] # Support multiple data blocks in a single SMTP session
+      @processor.process_email_alert(message)
+
+      # WARNING: this MUST return true, otherwise Monit will try to send alerts over and over again
+      true
+    end
+
+  end
+
+end
+