gaddygaddy 0.1.78

data/lib/gaddygaddy-client.rb~

@@ -0,0 +1,425 @@
+#
+# Name:
+#   gaddygaddy-client.rb
+#
+# Created by: mansson
+#
+# Description:
+#
+#
+#
+# Copyright (c) 2013 GaddyGaddy
+#
+# All rights reserved.
+#
+
+APPLICATION_NAME = "gaddygaddy-client"
+
+require 'gg_config/gg_config'
+require 'device_info/device_info'
+require 'fileutils'
+require 'utils/hash_monkeypatch'
+require 'json'
+require 'subcommand'
+require 'gaddygaddy-client/chef_management'
+require 'logging/logging'
+require 'restclient'
+require 'systemu'
+require 'utils/request'
+require 'utils/retriable'
+require 'error_constants'
+
+REVISION = "$Revision: 1 $"[10..-3].chomp
+
+DEFAULT_CHEF_DIR = "/var/chef"
+DEFAULT_CONF_DIR = "/conf"
+DEFAULT_CONF_FILE = "gaddy_*.gcf"
+CONFIG_FILE_NAME = "node.json"
+
+class TokenJException < JException;end
+class CreateDeviceJException < JException;end
+
+class GaddyGaddy_Client
+
+  include Logging
+  include Subcommands
+  include Retriable
+  extend  Retriable
+
+  def initialize
+    logger.outputters = Log4r::Outputter.stdout
+  end
+
+  def usage
+    puts "gaddygaddy-client [OPTIONS]"
+    puts "The client to run for the GaddyGaddy service"
+    puts "For more information about the commands run gaddygaddy-client --help"
+    puts "Revision :#{REVISION}"
+    puts
+  end
+
+  def read_options
+    # This hash will hold all of the options
+    # parsed from the command-line by
+    # OptionParser.
+    @options = {}
+
+
+    global_options do |opts|
+      opts.banner = "Usage: gaddygaddy-client [options] [subcommand [options]]"
+      opts.description = "GaddyGaddy client for the GaddyGaddy service"
+      opts.separator ""
+      opts.separator "Global options are:"
+
+      @options[:conf_dir] = DEFAULT_CONF_DIR
+      opts.on( '--config_dir CONF-DIR', "Directory containing the client configuration files, default is #{DEFAULT_CONF_DIR}" ) do |conf_dir|
+        @options[:conf_dir] = conf_dir
+      end
+
+      @options[:conf_file] = DEFAULT_CONF_FILE
+      opts.on( '--config_file CONF-FILE', "File name (without) path for the configuration file, default is #{DEFAULT_CONF_FILE}" ) do |conf_file|
+        @options[:conf_file] = conf_file
+      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[:file_host] = "config.gaddygaddy.com:84"
+      opts.on( '--file_host FILE_HOST', 'The file host to get files like cookbooks from' ) do|file_host|
+        @options[:file_host] = file_host
+      end
+
+      @options[:host] = "ap.gaddygaddy.com:82"
+      opts.on( '-H', '--host HOST', 'The host to connect to' ) do|host|
+        @options[:host] = host
+      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[:test_mode] = false
+      opts.on( '--test_mode', 'Used for testing, will only retry once for example' ) do
+        @options[:test_mode] = true
+      end
+
+      @options[:token] = nil
+      opts.on( '-t', '--token TOKEN', 'The token to be used to access' ) do|token|
+        @options[:token] = token
+      end
+
+
+
+    end
+
+    add_help_option
+
+    command :get_cookbooks do |opts|
+      opts.banner = "Usage: get_cookbooks [options]"
+      opts.description = "Will download the cookbooks from the GaddyGaddy service"
+      @options[:chef_dir] = DEFAULT_CHEF_DIR
+      opts.on( '--chef_dir CHEF-DIR', "The chef dir to place the files into, default is #{DEFAULT_CHEF_DIR}" ) do |chef_dir|
+        @options[:chef_dir] = chef_dir
+      end
+      @options[:cookbooks_version] = nil
+      opts.on( '--cookbooks_version COOKBOOKS_VERSION', "Override the setting of which cookbook version to download" ) do |cookbooks_version|
+        @options[:cookbooks_version] = cookbooks_version
+      end
+    end
+
+    command :chef_config do |opts|
+      opts.banner = "Usage: chef_config [options]"
+      opts.description = "Will download the config and place it in a directory"
+    end
+
+    command :init_config do |opts|
+      opts.banner = "Usage: init_config [options]"
+      opts.description = "Will init the config, will check that config files doesn't exist"
+    end
+
+    command :verify_installation do |opts|
+      opts.banner = "Usage: verify_installation[options]"
+      opts.description = "Will verify the installation and check for gaddy file and network configuration"
+    end
+    cmd = nil
+    begin
+      cmd = opt_parse
+      mandatory =  []
+      missing = mandatory.select{ |param| @options[param].nil? }
+      unless missing.empty?
+        puts "Missing options: #{missing.join(', ')}"                  #
+        puts opt_parse                                                  #
+        exit 1
+      end
+      unless cmd
+        puts "No command is specified\n\n"
+        usage
+        puts print_actions
+        exit 1
+      end
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument      #
+      puts $!.to_s                                                           # Friendly output when parsing fails
+      puts opt_parse                                                          #
+      exit 1                                                                #
+    end
+    cmd
+  end
+
+  def gg_config
+    @gg_config ||= GGConfig.new(:conf_dir => @options[:conf_dir], :conf_file => @options[:conf_file])
+  end
+
+  def get_property(property_name)
+    file_name = File.join(conf_dir, "gaddygaddy.property")
+    value = nil
+    if File.exists? file_name
+      prop_file = File.open(File.join(conf_dir, "gaddygaddy.property"), "r")
+      prop_file.read_lines.each do |line|
+        prop, prop_value = line.split("=")
+        if prop.strip == property_name
+          value = value.strip
+        end
+      end
+    end
+    value
+  end
+
+  # Get the config directory
+  def conf_dir
+    @options[:conf_dir]
+  end
+
+  # Should try to get the host from options or config
+
+  def get_host
+    @options[:host]
+  end
+
+  # Get the version of cookbook installed at the system
+
+  def get_installed_cookbook_version
+    get_property "gaddygaddy.cookbooks.installed_version"
+  end
+
+  def get_cookbook_version
+    url = Request.get_base_url(get_host) + "/chef/cookbooks_version/1/#{user_id_salt}/#{device_id}/#{get_token}"
+    response = Request.client_service_get url
+    raise "Could not get cookbook version" unless response['cookbooks_version']
+    logger.debug "Got cookbook version: #{response}"
+    response['cookbooks_version']
+  end
+
+  def device_id
+    gg_config.config[:device_id]
+  end
+
+  def get_chef_config_file
+    url = Request.get_base_url(get_host) + "/chef/node_json/1/#{user_id_salt}/#{device_id}/#{get_token}"
+    response = Request.client_service_get url
+    raise "Could not get config file for device #{device_id}" unless response["run_list"].length > 0
+    logger.debug "Got config file: #{response}"
+    response
+  end
+
+  def get_chef_config
+    begin
+      FileUtils.mkdir_p conf_dir
+    rescue Exception => e
+      raise e.inspect
+    end
+    conf_content = get_chef_config_file
+    chef_config = conf_content['variables']
+    chef_config['run_list'] = conf_content['run_list']
+
+    conf_file = File.open File.join(conf_dir, CONFIG_FILE_NAME), "w"
+    conf_file.write chef_config.to_json
+    conf_file.close
+  end
+
+  # Check that the config file exist and has valid content, this will also be validated toward the server
+  def config_valid
+    config_ok = false
+    config_file_name = Dir.glob(File.join(conf_dir, @options[:conf_file]))[0]
+    logger.debug "Will validate config for #{config_file_name}"
+    if File.exists?(config_file_name)
+      begin
+        conf_file = File.open(config_file_name)
+        config = JSON.parse(conf_file.read)
+      rescue Exception => e
+        raise "Could not read from file #{config_file_name}"
+      end
+      logger.debug "Have read from file #{config_file_name}"
+      config_ok = config["device_id"]
+    end
+    # TODO validate the client against the client service
+    config_ok
+  end
+
+  # Get a device id, to start with only implemented for Raspberry
+  def hardware_id
+    hardware_id = `cat /proc/cpuinfo|grep Serial`.strip[10..-1].to_s.strip
+    logger.debug "The device id is #{hardware_id}"
+    if hardware_id == ""
+      hardware_id = 'test_device'
+    end
+    raise JNoDeviceIDFound.new({:message => "Could not found a device id for this computer, a device id is needed, see further help"}) unless hardware_id
+    hardware_id
+  end
+
+  # Get teh user name from the config
+  def user_email
+    # This to avoid characters like + replaced with space
+    gg_config.get_user_email
+  end
+
+  def user_id_salt
+    gg_config.get_user_id_salt
+  end
+
+
+  # Create a new config by requesting it from the server
+  def create_new_config
+    url = Request.get_base_url(get_host) + "/chef/add_device_for_user/1/#{CGI.escape(CGI.escape(user_email))}"
+    response = Request.client_service_get url
+    url_config = URI.encode(Request.get_base_url(get_host) + "/device/config_file/1/#{response['device_id']}/#{response['user_id_salt']}/#{response['token']}")
+    response_config = Request.client_service_get url_config
+    logger.debug response_config.class
+    logger.debug response_config.inspect
+    response = response_config
+    raise JNoDeviceIDFound if response_config['status'].to_i != 0
+    gg_config.config = response['config']
+    gg_config.save
+  end
+
+  # init the configuration by trying to get the node config, if that doesn't exist then create a new config
+  def init_config
+    begin
+      get_chef_config_file
+    rescue JNoGaddyGaddyConfigFile
+    end
+    return if config_valid
+    create_new_config
+    @device_info.post
+  end
+
+  def get_token
+    # TODO get this from config file
+    token = gg_config.config[:token]
+    raise TokenJException.new({:status => ERR_NO_VALID_TOKEN, :message => "No token specified"}) unless token
+    token
+  end
+
+  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
+
+  def get_cookbook
+    version = @options[:cookbooks_version] ? @options[:cookbooks_version] : get_cookbook_version.to_s
+    installed_version = get_installed_cookbook_version.to_s
+    tmp_file = "/tmp/cookbooks-#{version}.tar.gz"
+    port = 80
+    file_host = @options[:file_host]
+    # The file host should be without http or port
+    file_host = file_host.split("://")[1] if file_host.index("://")
+    file_host,port = file_host.split(":") if file_host.index(":")
+    Net::HTTP.start(file_host, port) do |http|
+      begin
+        file = open(tmp_file, 'wb')
+        cookbook_path = '/' + URI.encode("pkg/gg_chef_#{version}.tar.gz")
+        logger.debug "Will request the cookbooks files from http://#{file_host}:#{port}#{cookbook_path}"
+        result = http.request_get(cookbook_path) do |response|
+          response.read_body do |segment|
+            file.write(segment)
+          end
+        end
+        logger.debug "The tar cookbook request response was #{result.inspect}"
+      ensure
+        file.close
+      end
+    end
+    logger.debug "Will untar the file to #{@options[:chef_dir]} and then remove file #{tmp_file}"
+    FileUtils.mkdir_p @options[:chef_dir]
+    cmd = "tar -C #{@options[:chef_dir]} -zxvf #{tmp_file}"
+    run_cmd cmd
+    cmd_remove = "rm #{tmp_file}"
+    run_cmd cmd_remove
+  end
+
+  def self.alert(type)
+    alert_timing = case type
+                     when :no_config_file
+                       {:on => 0.1, :off => 0.1,:alert_text => 'Could not found any gaddy config file in /conf/gaddy_XXXX.gcf'}
+                     when :no_network
+                       {:on => 1,:off => 1, :alert_text => 'Could not connect to internet, network configuration seams broken'}
+                   end
+    begin
+      `echo none >/sys/class/leds/led0/trigger`
+      count = 0
+      send_info_count = 20 / (alert_timing[:on] + alert_timing[:off])
+      while true do
+        if (count % send_info_count) == 0
+          puts alert_timing[:alert_text]
+          `/usr/bin/espeak "#{alert_timing[:alert_text]}"`
+        end
+        `echo 1 >/sys/class/leds/led0/brightness`
+        sleep alert_timing[:on]
+        `echo 0 >/sys/class/leds/led0/brightness`
+        sleep alert_timing[:off]
+        count += 1
+      end
+    ensure
+      `echo mmc0 >/sys/class/leds/led0/trigger`
+    end
+  end
+
+  def self.ip_to_verify
+    '8.8.8.8'
+  end
+
+  def self.network_ok?
+    ping_result = `ping -w 10 #{ip_to_verify} -c 1`
+    logger.debug "Result of ping is #{ping_result}"
+    ! ping_result.index("100% packet loss")
+  end
+
+  # Verify that we have a conf file and verify network connection
+  def self.verify_installation
+    conf_file = Dir.glob(File.join('/','conf', "gaddy*.gcf"))
+    alert(:no_config_file) if conf_file.empty?
+    alert(:no_network) unless network_ok?
+  end
+
+  def run
+    cmd = read_options
+    begin
+      Retriable.set_test_mode if @options[:test_mode]
+      @device_info = DeviceInfo.new(get_host, gg_config)
+      set_log_level @options[:log_level]
+      set_log_file @options[:log_file] if @options[:log_file]
+      logger.info "Will start #{APPLICATION_NAME} with command #{cmd}"
+      case cmd
+        when "get_cookbooks"
+          get_cookbook
+        when "chef_config"
+          get_chef_config
+        when "init_config"
+          init_config
+        when "verify_installation"
+          self.class.verify_installation
+        else
+          usage
+          raise "No valid command entered, the command is #{cmd}"
+      end
+
+    rescue Exception => e
+      logger.error e.message
+      logger.error "Enable full stack trace with -l DEBUG" unless logger.debug?
+      logger.error "Backtrace:\n\t#{e.backtrace.join("\n\t")}" if logger.debug?
+
+    end
+  end
+end

data/lib/gg_config/gg_config.rb

@@ -0,0 +1,162 @@
+#
+# Name:
+#   config.rb  
+#
+# Created by: GaddyGaddy
+#
+# Description:
+#   
+#
+#
+# Copyright (c) 2013 GaddyGaddy
+#
+# All rights reserved.
+# 
+
+
+$LOAD_PATH << File.expand_path('../../../../gg_common/lib',__FILE__)
+
+require 'error_constants'
+require 'jexception'
+require_relative '../logging/logging'
+require 'topic_constants'
+
+class GGConfig
+  include Logging
+
+  def initialize(options = {:conf_dir => "/conf", :conf_file => "gaddy_*.gcf"} )
+    @conf_file = options[:conf_file]
+    @conf_dir = File.expand_path(options[:conf_dir])
+  end
+
+
+  def device_id
+    config[:device_id]
+  end
+
+  def get_device_name
+    device_name = get_config_for(:device_name,"host","device")
+    unless valid_host_name?(device_name)
+      raise JException.new({:message => "The host name #{device_name} is not a valid host name",
+                            :status => ERR_NO_VALID_HOSTNAME,
+                            :extra_info => {:host_name => device_name}
+                           })
+    end
+    device_name
+  end
+
+  def token
+    config[:token]
+  end
+
+  def user_email
+    get_config_for(:user_email,"user","user")
+  end
+
+  def user_id_salt
+    get_config_for(:user_id_salt,"user","user_id_salt")
+  end
+
+
+
+  # Get the config file name
+  def config_file_name
+    Dir.glob(File.join(@conf_dir, @conf_file))[0]
+  end
+
+  def read_config_file
+    begin
+      config_file = File.open(config_file_name)
+      file_content = config_file.read
+      config = JSON.parse(file_content)
+      logger.debug "Have read config file #{config_file_name} and found content #{config.to_s}"
+    rescue Exception => e
+      raise JNoGaddyGaddyConfigFile.new({:message => e.message})
+    end
+    config.symbolize_keys!
+  end
+
+  def config
+    @config_content ||= read_config_file
+  end
+
+  def config= (new_config)
+    @config_content = new_config.symbolize_keys!
+  end
+
+  def valid_host_name?(host_name)
+    host_name.size <= 63 and not (host_name.rindex('-', 0) or host_name.index('-', -1) or host_name.scan(/[^a-z\d-]/i).any?)
+  end
+
+  def save
+    unless valid_config?
+      raise JCouldNotSaveConfigFileException.new({:message => "Missing configuration information, could not save config file for #{config.inspect}"})
+    end
+    begin
+      config_file = File.open(config_file_name,"w")
+      config_file.write config.to_json.to_s
+    rescue Exception => e
+      raise JCouldNotSaveConfigFileException.new({:message => e.message})
+    end
+  end
+
+
+  # Generic method to get the initial config for a config_type, could be device_name or user_name, will also try
+  # to find all kind of configs files with device_name or user_name
+  def get_config_for(config_type, conf_name, extra_conf_file)
+    config_value = nil
+    begin
+      if config
+        logger.debug "Config exist and is #{config} looking for config type #{config_type}"
+        config_value = config[config_type]
+      end
+    rescue Exception => e
+      logger.info "Could not find a gaddygaddy config file, message is #{e.message}"
+    end
+    unless config_value
+      files = Dir.glob(File.join(@conf_dir, 'config.*'))
+      files << File.join(@conf_dir, extra_conf_file) if File.exist? File.join(@conf_dir, extra_conf_file)
+      files.each do |conf_file_name|
+        logger.debug "The file #{conf_file_name} has file size #{File.size(conf_file_name)}"
+        if File.size(conf_file_name).to_i < 1000
+          conf_file = File.open(conf_file_name,"r")
+          lines = conf_file.readlines
+          # Check if there are not a lot of lines in the config
+          if lines.size < 4
+            lines.each do |line|
+              if line.index("=")
+                args = line.split("=")
+                # Validate that the syntax of the property is ok
+                if args.size == 2
+                  config_value = args[1].strip if args[0].strip == conf_name || args[0].strip == "config_value"
+                else
+                  logger.info "The file #{conf_file_name} has too many = in the line #{line}"
+                end
+              else
+                # Validate that there are no spaces in the config_value
+                config_value = line.strip
+              end
+            end
+          else
+            logger.info "The file #{conf_file_name} is not a config file as it's too many lines"
+          end
+        else
+          logger.info "Will not check file #{conf_file_name} as it is to big"
+        end
+      end
+    end
+    # Check that we have found a config_value and that the config_value is a valid host name, if not raise a exception with topic info to be able to help the user further
+    unless config_value
+      raise JNoGaddyGaddyConfigFile.new({:message => "Could not found any file with config in the config dir #{@conf_dir}",
+                                         :topic => TPC_NO_CONFIG_FILE,
+                                         :extra_info => {:conf_dir => @conf_dir}
+                                        })
+    end
+    config_value
+  end
+
+  def valid_config?
+    config[:user_id_salt] && config[:token] && config[:device_name]
+  end
+
+end