gaddygaddy 0.1.78

data/lib/interval.rb

@@ -0,0 +1,280 @@
+APPLICATION_NAME = "interval"
+
+require 'optparse'
+require 'json'
+require 'logging/logging'
+require 'systemu'
+require 'uri'
+
+SENSU_HOST = "127.0.0.1"
+
+class Interval
+  include Logging
+
+  ##################################################################
+  # Read and parse command line options
+  #
+  def read_options(argv)
+    @options = {}
+    optparse = OptionParser.new do|opts|
+      opts.banner = "Usage: interval [options] -p <proc_name> -c <command_to_run>"
+
+      @options[:proc_name] = nil
+      opts.on( '-p', '--proc_name <name>', 'Process name to use' ) do |proc_name|
+        @options[:proc_name] = proc_name
+      end
+
+      @options[:cmd] = nil
+      opts.on( '-c', '--cmd <path>', 'Command to run' ) do |cmd|
+        @options[:cmd] = cmd
+      end
+
+      opts.on( '-u', '--uri_cmd <path>', 'Command to run (URI-encoded)' ) do |ucmd|
+        @options[:cmd] = URI.unescape(ucmd)
+      end
+
+      @options[:config_name] = nil
+      opts.on( '-C', '--config_name <name>', 'Config name to use' ) do |config_name|
+        @options[:config_name] = config_name
+      end
+
+      @options[:home] = nil
+      opts.on( '-h', '--home <home>', 'Home directory of application' ) do |home|
+        @options[:home] = home
+      end
+
+      @options[:log_file] = nil
+      opts.on( '-l', '--logfile FILE', 'Write log to FILE, defaults to STDOUT' ) do |file|
+        @options[:log_file] = file
+      end
+
+      @options[:log_level] = 'info'
+      opts.on( '-L', '--log_level level', 'Set the log level (debug, info, warn, error, fatal)' ) do| level|
+        @options[:log_level] = level
+      end
+
+      @options[:count] = nil
+      opts.on( '-n', '--num <count>', 'Run the command <count> times and then exit (use for testing)' ) do |count|
+        @options[:count] = count.to_i
+      end
+
+      @options[:fail_on_error] = false
+      opts.on( '-f', '--fail_on_error', 'Abort if the program fails' ) do
+        @options[:fail_on_error] = true
+      end
+
+      @options[:sensu_enabled] = false
+      opts.on( '-z', '--sensu', 'Do report status to Sensu' ) do
+        @options[:sensu_enabled] = true
+      end
+
+      @options[:sensu_port] = 3030
+      opts.on( '--sensu_port <port>', Integer, 'Port to talk to sensu on' ) do |port|
+        @options[:sensu_port] = port
+      end
+
+      @options[:status_file] = nil
+      opts.on( '-s', '--status_file <status>', 'File to write last run status to' ) do |status|
+        @options[:status_file] = status
+      end
+
+      @options[:interval] = nil
+      opts.on( '-i', '--interval <interval>', 'Time between runs of program (seconds if no unit is specified)' ) do |interval|
+        @options[:interval] = interval
+      end
+
+      @options[:time_stamp] = nil
+      opts.on( '-t', '--time <time>', 'Run command at a specific time each day, could be comma separated. Format HHMM. Example 1430,0230 will run the command at 14:30 and 02:30 each day' ) do |time|
+        @options[:time_stamp] = time.split(",")
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end
+
+    begin
+      optparse.parse!(argv)
+      if @options[:config_name].nil?
+        @options[:config_name] = @options[:proc_name]
+      end
+      mandatory = [:proc_name, :cmd]
+      missing = mandatory.select{ |param| @options[param].nil? }
+      unless missing.empty?
+        STDERR.puts "Missing options: #{missing.join(', ')}"
+        STDERR.puts optparse
+        exit 1
+      end
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument  #
+      STDERR.puts $!.to_s                                                     # Friendly output when parsing fails
+      STDERR.puts optparse                                                    #
+      exit 1                                                           #
+    end
+  end
+
+  ##################################################################
+  # Parse a time expression
+  #
+  # The argument should be in one of the following forms
+  #   <number>   - parsed as seconds
+  #   <number>s  - parsed as seconds
+  #   <number>m  - parsed as minutes
+  #   <number>h  - parsed as hours
+  # 
+  # @param s [String] String to parse
+  #
+  # return [Numeric] number of seconds time represents
+
+  def parse_time(s)
+    case s
+      when /^\d+s?$/
+        s.to_i
+      when /^\d+m$/
+        s.to_i * 60
+      when /^\d+h$/
+        s.to_i * 60 * 60
+      else
+        -1
+    end
+  end
+
+  ##################################################################
+  # Store status on disk
+  def store_status(exit_code)
+    if @options[:status_file]
+      File.open(@options[:status_file], 'w') do |f| f.puts("result=#{exit_code}") end
+    end
+  end
+
+  ##################################################################
+  # Fail, exit with an error message
+  def my_fail(msg)
+    logger.fatal msg if logger
+    STDERR.puts msg
+    send_to_sensu(1, "Error running interval for #{@options[:proc_name]}, #{msg}")
+    store_status 1
+    exit 1
+  end
+
+  ###################################################################
+  # Send message to sensu
+  #
+  def send_to_sensu(status, message)
+    if @options[:sensu_enabled]
+      report = {
+          :name => "interval_error_#{@options[:proc_name]}",
+          :output => "",
+          :status => status
+      }
+      if status != 0
+        report[:output] = "Failed to run #{@options[:proc_name]} #{message}"
+      end
+
+      begin
+        s = TCPSocket.open(SENSU_HOST, @options[:sensu_port])
+        s.print JSON.generate(report)
+        s.close
+      rescue Exception => e
+        logger.error "Failed to send report to sensu: #{e.message}"
+      end
+    end
+  end
+
+  def get_prop(option_name)
+    prop_value = nil
+    if @options[option_name]
+      prop_value = @options[option_name]
+    end
+    logger.debug "Found value #{prop_value} for #{option_name.to_s}"
+    prop_value
+  end
+
+  def run
+    read_options(ARGV)
+
+    # Check binary
+    unless File.executable?(@options[:cmd].split[0])
+      my_fail "Specified binary '#{@options[:cmd]}' does not exist or is not executable"
+    end
+
+    set_log_level @options[:log_level]
+    set_log_file @options[:log_file] if @options[:log_file]
+
+    if @options[:home]
+      Dir.chdir(@options[:home])
+    end
+
+    # Get properties
+    conf_name = @options[:config_name] ? @options[:config_name] : @options[:proc_name]
+
+    begin
+      interval_in = get_prop :interval
+      if interval_in
+        interval = parse_time interval_in
+        logger.info "Using an run interval of #{interval} seconds"
+        if interval < 1
+          my_fail "Illegal interval #{interval} given for property #{conf_name}.run.interval"
+        end
+
+      else
+        time_stamp = get_prop :time_stamp
+        raise "Could not found interval or time_stamp option, one of those is needed" unless time_stamp
+        logger.info "Will run at time stamp #{time_stamp.join(",")}"
+      end
+    rescue StandardError => e
+      puts e.message
+      my_fail "Did not find config value for #{conf_name}"
+    end
+
+
+    logger.info "Starting interval #{@options.inspect}"
+
+    store_status 0
+
+    count = 0
+    first = true
+    loop do
+      unless time_stamp && first
+        count = count+1
+        logger.info "Launching[#{count}]: #{@options[:cmd]}"
+        result, stdout, stderr = systemu @options[:cmd]
+        store_status result.exitstatus
+        if result != 0
+          logger.error "Failed to run #{@options[:cmd]} (exit code #{result})"
+          logger.error "Stdout: #{stdout.strip}" if stdout.length > 0
+          logger.error "Stderr: #{stderr.strip}" if stderr.length > 0
+          send_to_sensu(1, "Result is #{result}. Stderr is: #{stderr}, stdout is #{stdout}")
+          if @options[:fail_on_error]
+            exit result
+          end
+        else
+          logger.info "Command completed successfully"
+          logger.info "Stdout: #{stdout.strip}" if stdout.length > 0
+          send_to_sensu(0, "")
+        end
+      end
+      first = false
+
+      if @options[:count] && count >= @options[:count]
+        exit 0
+      end
+      if time_stamp
+        diff = []
+        time_stamp.each do |time|
+          current = Time.now.strftime("%H%M%S")
+          diff_time = ((time[0..1].to_i * 60 + time[2..3].to_i) - (current[0..1].to_i * 60 + current[2..3].to_i))*60 - current[4..5].to_i
+          diff_time += 24*60*60 if diff_time <= 0
+          diff << diff_time
+        end
+        logger.debug "sleep for #{diff.min + 1} seconds"
+        sleep diff.min + 1
+      else
+        logger.debug "sleep for #{interval} seconds"
+        sleep interval
+      end
+    end
+  end
+
+end
+

data/lib/logging/logging.rb

@@ -0,0 +1,62 @@
+#
+# Name:
+#   logging.rb
+#
+# Created by: GaddyGaddy
+#
+# Description:
+#   
+#
+#
+# Copyright (c) 2013 GaddyGaddy
+#
+# All rights reserved.
+# 
+
+require 'log4r'
+require 'log4r/outputter/datefileoutputter'
+require 'log4r/yamlconfigurator'
+
+module Logging
+  # This is the magical bit that gets mixed into your classes
+  @@log_conf = const_defined?(:APPLICATION_NAME) ? APPLICATION_NAME : "default"
+
+  def logger
+    Logging.logger
+  end
+
+  def set_log_level(level_str)
+    logger.level = (Log4r::Log4rConfig::LogLevels.index level_str.upcase) + 1
+  end
+
+  def set_log_file(new_filename)
+    format = Log4r::PatternFormatter.new(:pattern => "[%5l] %d :: %m", :date_pattern => '%y%m%d %H:%M:%S')
+    dir_name = File.dirname(new_filename)
+    file_name = File.basename(new_filename)
+    logger.outputters << Log4r::DateFileOutputter.new('log_file', :filename => file_name, :dirname => dir_name, :formatter => format, :date_pattern => '%Y%m%d')
+  end
+
+  def self.set_log_conf log_conf
+    @@log_conf = log_conf
+  end
+
+  # create a new log4r logger with config
+
+  def self.create_logger
+    log_cfg = Log4r::YamlConfigurator
+    conf_file = File.join(File.dirname(__FILE__), "..", "..", "conf","log4r.yml")
+    log_cfg.load_yaml_file(conf_file)
+
+    # app logger
+    new_logger = Log4r::Logger[@@log_conf]
+    raise "Missing logger config #{@@log_conf} in log config file #{conf_file}" unless new_logger
+    new_logger.level = Log4r::INFO
+    new_logger.info "Log initiated"
+    new_logger
+  end
+
+  # Global, memoized, lazy initialized instance of a logger
+  def self.logger
+    @logger ||= create_logger
+  end
+end

data/lib/utils/hash_monkeypatch.rb

@@ -0,0 +1,34 @@
+#
+# Name:
+#   hash.rb  
+#
+# Created by: GaddyGaddy
+#
+# Description:
+#   
+#
+#
+# Copyright (c) 2013 GaddyGaddy
+#
+# All rights reserved.
+# 
+
+class Hash
+ # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  # { 'name' => 'Rob', 'years' => '28' }.symbolize_keys
+  # #=> { :name => "Rob", :years => "28" }
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+    end
+end

data/lib/utils/request.rb

@@ -0,0 +1,52 @@
+#
+# Name:
+#   requests.rb  
+#
+# Created by: GaddyGaddy
+#
+# Description:
+#   
+#
+#
+# Copyright (c) 2013 GaddyGaddy
+#
+# All rights reserved.
+#
+require 'cgi'
+
+require_relative '../utils/retriable'
+require_relative '../logging/logging'
+class Request
+  extend Logging
+  extend  Retriable
+
+  # Get a base url for accessing the client service
+  # TODO Change this to https but we need a certificate for that
+  def self.get_base_url(host)
+    url = host
+    url = "http://" + url unless url[0..3] == "http"
+    url
+  end
+
+
+  #
+  # Will do a request
+  # path will be evaluated so there could be parameters in that one and then use ''  for the string
+  # to have the parameters evaluated in this function
+  #
+  def self.client_service_get(host, path)
+    url = get_base_url(host) + path
+    logger.debug "Will request url #{url}"
+    result = with_retries(:limit => 10, :sleep=> 5) { RestClient.get url }
+    result_json = JSON.parse(result)
+    logger.debug "The result of the request is #{result.inspect}"
+    result_json
+  end
+
+  def self.client_service_post(url, param)
+    logger.debug "Will request url #{url}"
+    result = with_retries(:limit => 10, :sleep=> 5) { RestClient.post url, param }
+    JSON.parse(result)
+  end
+
+end

data/lib/utils/retriable.rb

@@ -0,0 +1,63 @@
+#
+# Name:
+#   retriable.rb
+#
+# Created by: GaddyGaddy
+#
+# Description:
+#
+#
+#
+
+module Retriable
+
+  @@test_mode = false
+
+  # This will catch any exception and retry twice (three tries total):
+  #   with_retries { ... }
+  #
+  # This will catch any exception and retry four times (five tries total):
+  #   with_retries(:limit => 5) { ... }
+  #
+  # This will catch a specific exception and retry once (two tries total):
+  #   with_retries(Some::Error, :limit => 2) { ... }
+  #
+  # You can also sleep inbetween tries. This is helpful if you're hoping
+  # that some external service recovers from its issues.
+  #   with_retries(Service::Error, :sleep => 1) { ... }
+  #
+  def with_retries(*args, &block)
+
+    options = extract_options args
+    exceptions = args
+
+    options[:limit] ||= 3
+    options[:limit] = 0 if @@test_mode
+    options[:sleep] ||= 0
+    exceptions = [Exception] if exceptions.empty?
+
+    retried = 0
+    begin
+      yield
+    rescue *exceptions => e
+      logger.warn "Could not do command, will retry. Error message is #{e.inspect.to_s}"
+      if retried + 1 < options[:limit]
+        retried += 1
+        sleep options[:sleep]
+        retry
+      else
+        raise e
+      end
+    end
+  end
+
+  def extract_options(array)
+    array.last.is_a?(::Hash) ? array.pop : {}
+  end
+
+  def self.set_test_mode
+    @@test_mode = true
+  end
+
+
+end

data/lib/utils/run.rb

@@ -0,0 +1,20 @@
+#
+# Name:
+#   run.rb
+#
+# Created by: GaddyGaddy
+#
+# Description:
+#
+#
+#
+# Copyright (c) 2013 GaddyGaddy
+#
+# All rights reserved.
+#
+
+
+def run_cmd(cmd)
+  status, stdout, stderr = systemu cmd
+  raise "Could not run command: #{cmd}, stdout is #{stdout}, error message is #{stderr}" if status != 0
+end

data/locales/en.yml

@@ -0,0 +1,24 @@
+en:
+  event:
+    converge:
+      chef_failed: ! 'Installation of gaddy failed. Please contact the support. Installation failed at %s. Reason: %s and %s'
+      chef_failed_v1: ! 'Installation of gaddy failed. Please contact the support. Installation failed at %s. Reason: %s'
+      ok: The device has been successful installed
+      repair: Repair of installation done.
+      usb_drive_missing: A USB drive is not connected. It should be connected as %s
+    init:
+      config_updated: The device has been succesfully initiated, installation will now start
+      connected: The device is successful connected to internet
+    install:
+      installation_begin: Installation of gApp %s has started
+      installation_failed: Installation of gApp %s failed. The gApp is not running
+      installation_finished: Installation of gApp %s is finished
+    log:
+      error: Error in log %s message %s
+    not_running: ! '%s not working. '
+    not_running_v1: gApp is not running
+    ok: Running normally
+    spotify_config_not_ok: There is a problem with the Spotify configuration. Try to update username and password
+    vpn_proxy:
+      missing_user_or_password: Missing user name or password for vpn_proxy, check gApp
+      no_connection: Could not connect to the VPN server, check configuration

data/locales/sv.yml

@@ -0,0 +1,11 @@
+sv:
+  event:
+    converge:
+      chef_failed: 
+      ok: 
+    init:
+      config_updated: 
+      connected: 
+    install:
+      installation_begin: 
+      installation_finished: