interferon 0.1.0 → 0.1.3

data/lib/interferon/group_sources/filesystem.rb

@@ -3,7 +3,7 @@ include ::Interferon::Logging
 module Interferon::GroupSources
   class Filesystem
     def initialize(options)
-      raise ArgumentError, "missing paths for loading groups from filesystem" \
+      raise ArgumentError, 'missing paths for loading groups from filesystem' \
         unless options['paths']
 
       @paths = options['paths']
@@ -15,14 +15,14 @@ module Interferon::GroupSources
 
       @paths.each do |path|
         path = File.expand_path(path)
-        unless Dir.exists?(path)
+        unless Dir.exist?(path)
           log.warn "no such directory #{path} for reading group files"
           next
         end
 
         Dir.glob(File.join(path, '*.{json,yml,yaml}')).each do |group_file|
           begin
-            group = YAML::parse(File.read(group_file))
+            group = YAML.parse(File.read(group_file))
           rescue YAML::SyntaxError => e
             log.error "syntax error in group file #{group_file}: #{e}"
           rescue StandardError => e
@@ -32,7 +32,7 @@ module Interferon::GroupSources
             if group['people']
               groups[group['name']] = group['people'] || []
             elsif group['alias_for']
-              aliases[group['name']] = {:group => group['alias_for'], :group_file => group_file}
+              aliases[group['name']] = { group: group['alias_for'], group_file: group_file }
             end
           end
         end
@@ -48,7 +48,7 @@ module Interferon::GroupSources
         end
       end
 
-      return groups
+      groups
     end
   end
 end

data/lib/interferon/host_sources/aws_dynamo.rb

@@ -3,46 +3,44 @@ require 'aws'
 module Interferon::HostSources
   class AwsDynamo
     def initialize(options)
-      missing = %w{access_key_id secret_access_key}.reject{|r| options.key?(r)}
+      missing = %w(access_key_id secret_access_key).reject { |r| options.key?(r) }
 
-      AWS.config({
-          :access_key_id => options['access_key_id'],
-          :secret_access_key => options['secret_access_key']
-      }) if missing.empty?
+      AWS.config(access_key_id: options['access_key_id'],
+                 secret_access_key: options['secret_access_key']) if missing.empty?
 
       # initialize a list of regions to check
-      if options['regions'] && !options['regions'].empty?
-        @regions = options['regions']
-      else
-        @regions = AWS::regions.map(&:name)
-      end
+      @regions = if options['regions'] && !options['regions'].empty?
+                   options['regions']
+                 else
+                   AWS.regions.map(&:name)
+                 end
     end
 
     def list_hosts
       hosts = []
 
       @regions.each do |region|
-        client = AWS::DynamoDB.new(:region => region)
+        client = AWS::DynamoDB.new(region: region)
 
         AWS.memoize do
           client.tables.each do |table|
             hosts << {
-              :source => 'aws_dynamo',
-              :region => region,
-              :table_name => table.name,
+              source: 'aws_dynamo',
+              region: region,
+              table_name: table.name,
 
-              :read_capacity => table.read_capacity_units,
-              :write_capacity => table.write_capacity_units,
+              read_capacity: table.read_capacity_units,
+              write_capacity: table.write_capacity_units,
 
               # dynamodb does not support tagging
-              :owners => [],
-              :owner_groups => [],
+              owners: [],
+              owner_groups: [],
             }
           end
         end
       end
 
-      return hosts
+      hosts
     end
   end
 end

data/lib/interferon/host_sources/aws_elasticache.rb

@@ -3,19 +3,17 @@ require 'aws'
 module Interferon::HostSources
   class AwsElasticache
     def initialize(options)
-      missing = %w{access_key_id secret_access_key}.reject{|r| options.key?(r)}
+      missing = %w(access_key_id secret_access_key).reject { |r| options.key?(r) }
 
-      AWS.config({
-          :access_key_id => options['access_key_id'],
-          :secret_access_key => options['secret_access_key']
-      }) if missing.empty?
+      AWS.config(access_key_id: options['access_key_id'],
+                 secret_access_key: options['secret_access_key']) if missing.empty?
 
       # initialize a list of regions to check
-      if options['regions'] && !options['regions'].empty?
-        @regions = options['regions']
-      else
-        @regions = AWS::regions.map(&:name)
-      end
+      @regions = if options['regions'] && !options['regions'].empty?
+                   options['regions']
+                 else
+                   AWS.regions.map(&:name)
+                 end
     end
 
     def list_hosts
@@ -23,12 +21,12 @@ module Interferon::HostSources
 
       @regions.each do |region|
         clusters = []
-        client = AWS::ElastiCache.new(:region => region).client
+        client = AWS::ElastiCache.new(region: region).client
 
         AWS.memoize do
           # read the list of cache clusters; we have to do our own pagination
           clusters = []
-          options = {:show_cache_node_info => true}
+          options = { show_cache_node_info: true }
           loop do
             r = client.describe_cache_clusters(options)
             clusters += r.data[:cache_clusters]
@@ -41,26 +39,26 @@ module Interferon::HostSources
           clusters.each do |cluster|
             cluster[:cache_nodes].each do |node|
               hosts << {
-                :source => 'aws_elasticache',
-                :region => region,
+                source: 'aws_elasticache',
+                region: region,
 
-                :cluster_id => cluster[:cache_cluster_id],
-                :cluster_status => cluster[:cache_cluster_status],
-                :node_type => cluster[:cache_node_type],
-                :peer_nodes => cluster[:num_cache_nodes],
+                cluster_id: cluster[:cache_cluster_id],
+                cluster_status: cluster[:cache_cluster_status],
+                node_type: cluster[:cache_node_type],
+                peer_nodes: cluster[:num_cache_nodes],
 
-                :node_status => node[:cache_node_status],
+                node_status: node[:cache_node_status],
 
                 # elasticache does not support tagging
-                :owners => [],
-                :owner_groups => [],
+                owners: [],
+                owner_groups: [],
               }
             end
           end
         end
       end
 
-      return hosts
+      hosts
     end
   end
 end

data/lib/interferon/host_sources/aws_rds.rb

@@ -3,72 +3,71 @@ require 'aws'
 module Interferon::HostSources
   class AwsRds
     def initialize(options)
-      missing = %w{access_key_id secret_access_key}.reject{|r| options.key?(r)}
+      missing = %w(access_key_id secret_access_key).reject { |r| options.key?(r) }
 
-      AWS.config({
-          :access_key_id => options['access_key_id'],
-          :secret_access_key => options['secret_access_key']
-      }) if missing.empty?
+      AWS.config(access_key_id: options['access_key_id'],
+                 secret_access_key: options['secret_access_key']) if missing.empty?
 
       # initialize a list of regions to check
-      if options['regions'] && !options['regions'].empty?
-        @regions = options['regions']
-      else
-        @regions = AWS::regions.map(&:name)
-      end
+      @regions = if options['regions'] && !options['regions'].empty?
+                   options['regions']
+                 else
+                   AWS.regions.map(&:name)
+                 end
     end
 
     def list_hosts
       hosts = []
 
       @regions.each do |region|
-        rds = AWS::RDS.new(:region => region)
+        rds = AWS::RDS.new(region: region)
 
         AWS.memoize do
           rds.instances.each do |instance|
             # get the tags for the instance
             arn = arn(region, instance.id)
-            tag_list = rds.client.list_tags_for_resource(:resource_name => arn)[:tag_list]
-            tags = Hash[ tag_list.map { |h| [h[:key], h[:value]] } ]
+            tag_list = rds.client.list_tags_for_resource(resource_name: arn)[:tag_list]
+            tags = Hash[tag_list.map { |h| [h[:key], h[:value]] }]
 
             tags['owners'] ||= ''
             tags['owner_groups'] ||= ''
 
             # build the host data for this instance
             hosts << {
-              :source => 'aws_rds',
-              :region => region,
-              :instance_id => instance.id,
-              :db_name => instance.db_name,
-              :engine => instance.engine,
-              :engine_version => instance.engine_version,
+              source: 'aws_rds',
+              region: region,
+              instance_id: instance.id,
+              db_name: instance.db_name,
+              engine: instance.engine,
+              engine_version: instance.engine_version,
 
               # metrics
-              :allocated_storage => instance.allocated_storage,
-              :iops => instance.iops,
+              allocated_storage: instance.allocated_storage,
+              iops: instance.iops,
 
               # replication info
-              :is_replica => !instance.read_replica_source_db_instance_identifier.nil?,
-              :replica_source_name => instance.read_replica_source_db_instance_identifier,
-              :replica_names => instance.read_replica_db_instance_identifiers.join(','),
-              :replicas => instance.read_replica_db_instance_identifiers.count,
+              is_replica: !instance.read_replica_source_db_instance_identifier.nil?,
+              replica_source_name: instance.read_replica_source_db_instance_identifier,
+              replica_names: instance.read_replica_db_instance_identifiers.join(','),
+              replicas: instance.read_replica_db_instance_identifiers.count,
 
-              :owners => tags['owners'].split(','),
-              :owner_groups => tags['owner_groups'].split(','),
+              owners: tags['owners'].split(','),
+              owner_groups: tags['owner_groups'].split(','),
 
-              :db_env => tags['db_env'],
-              :db_role => tags['db_role'],
+              db_env: tags['db_env'],
+              db_role: tags['db_role'],
             }
           end
         end
       end
 
-      return hosts
+      hosts
     end
 
     private
+
     def arn(region, instance_id)
-      return "arn:aws:rds:#{region}:#{account_number}:db:#{instance_id}"
+      "arn:aws:rds:#{region}:#{account_number}:db:#{instance_id}"
     end
 
     # unfortunately, this appears to be the only way to get your account number
@@ -77,8 +76,9 @@ module Interferon::HostSources
 
       begin
         my_arn = AWS::IAM.new(
-          :access_key_id => @access_key_id,
-          :secret_access_key => @secret_access_key).client.get_user()[:user][:arn]
+          access_key_id: @access_key_id,
+          secret_access_key: @secret_access_key
+        ).client.get_user[:user][:arn]
       rescue AWS::IAM::Errors::AccessDenied => e
         my_arn = e.message.split[1]
       end

data/lib/interferon/host_sources/optica.rb

@@ -6,7 +6,7 @@ module Interferon::HostSources
     include ::Interferon::Logging
 
     def initialize(options)
-      raise ArgumentError, "missing host for optica source" \
+      raise ArgumentError, 'missing host for optica source' \
         unless options['host']
 
       @host = options['host']
@@ -14,15 +14,17 @@ module Interferon::HostSources
     end
 
     def list_hosts
-      return optica_data['nodes'].map{|ip, host| {
-          :source => 'optica',
-          :hostname => host['hostname'],
-          :role => host['role'],
-          :environment => host['environment'],
+      optica_data['nodes'].map do |_ip, host|
+        {
+          source: 'optica',
+          hostname: host['hostname'],
+          role: host['role'],
+          environment: host['environment'],
 
-          :owners => host['ownership'] && host['ownership']['people'] || [],
-          :owner_groups => host['ownership'] && host['ownership']['groups'] || [],
-        }}
+          owners: host['ownership'] && host['ownership']['people'] || [],
+          owner_groups: host['ownership'] && host['ownership']['groups'] || [],
+        }
+      end
     end
 
     def optica_data
@@ -32,7 +34,7 @@ module Interferon::HostSources
         con.open_timeout = 60
 
         response = con.get('/')
-        JSON::parse(response.body)
+        JSON.parse(response.body)
       end
     end
   end

data/lib/interferon/host_sources/optica_services.rb

@@ -7,7 +7,7 @@ module Interferon::HostSources
     include ::Interferon::Logging
 
     def initialize(options)
-      raise ArgumentError, "missing host for optica source" \
+      raise ArgumentError, 'missing host for optica source' \
         unless options['host']
 
       @host = options['host']
@@ -22,24 +22,26 @@ module Interferon::HostSources
         con.open_timeout = 60
 
         response = con.get('/')
-        JSON::parse(response.body)
+        JSON.parse(response.body)
       end
     end
 
     def list_hosts
-      services = Hash.new{ |h,service| h[service] = {
-          :source => 'optica_services',
-          :service => service,
+      services = Hash.new do |h, service|
+        h[service] = {
+          source: 'optica_services',
+          service: service,
 
-          :owners => Set.new,
-          :owner_groups => Set.new,
-          :consumer_roles => Set.new,
-          :consumer_machine_count => 0,
-          :provider_machine_count => 0,
-        }}
+          owners: Set.new,
+          owner_groups: Set.new,
+          consumer_roles: Set.new,
+          consumer_machine_count: 0,
+          provider_machine_count: 0,
+        }
+      end
 
-      optica_data['nodes'].each do |ip, host|
-        next unless @envs.empty? or @envs.include?(host['environment'])
+      optica_data['nodes'].each do |_ip, host|
+        next unless @envs.empty? || @envs.include?(host['environment'])
 
         # make it easier by initializing possibly-missing data to sane defaults
         host['ownership'] ||= {}
@@ -62,13 +64,13 @@ module Interferon::HostSources
       end
 
       # convert all sets to arrays
-      services.each do |k,v|
+      services.each do |k, v|
         services[k][:owners] = v[:owners].to_a
         services[k][:owner_groups] = v[:owner_groups].to_a
         services[k][:consumer_roles] = v[:consumer_roles].to_a
       end
 
-      return services.values
+      services.values
     end
   end
 end

data/lib/interferon/host_sources/test_host_source.rb

@@ -1,6 +1,6 @@
 # we use this class to test dynamic loading in specs
 module Interferon::HostSources
   class TestHostSource
-    DIR = 'interferon'
+    DIR = 'interferon'.freeze
   end
 end

data/lib/interferon/loaders.rb

@@ -1,6 +1,5 @@
 
 module Interferon
-
   # lets create namespaces for things we'll be loading
   module Destinations; end
   module HostSources; end
@@ -40,7 +39,7 @@ module Interferon
           next
         end
 
-        if !enabled
+        unless enabled
           log.info "skipping #{@loader_for} #{type} because it's not enabled"
           next
         end
@@ -86,14 +85,14 @@ module Interferon
           klass = @module.const_get(class_name)
         rescue LoadError => e
           raise ArgumentError,\
-            "Loading Error; interferon does not define #{@loader_for} #{type}: #{e}"
+                "Loading Error; interferon does not define #{@loader_for} #{type}: #{e}"
         rescue NameError => e
           raise ArgumentError,\
-            "Name Error; class #{class_name} is not defined in #{relative_filename}: #{e}"
+                "Name Error; class #{class_name} is not defined in #{relative_filename}: #{e}"
         end
       end
 
-      return klass
+      klass
     end
   end
 

data/lib/interferon/logging.rb

@@ -3,12 +3,11 @@ require 'statsd'
 
 module Interferon
   module Logging
-
     def statsd
       @statsd ||= Statsd.new(
         Statsd::DEFAULT_HOST,
         Statsd::DEFAULT_PORT,
-        :namespace => 'alerts_framework'
+        namespace: 'alerts_framework'
       )
     end
 
@@ -20,7 +19,7 @@ module Interferon
       logger = Logger.new(STDERR)
       logger.level = Logger::INFO unless ENV['DEBUG']
       logger.progname = classname
-      return logger
+      logger
     end
   end
 end

data/lib/interferon/version.rb

@@ -1,3 +1,3 @@
 module Interferon
-  VERSION = "0.1.0"
+  VERSION = '0.1.3'.freeze
 end

data/lib/interferon/work_hours_helper.rb

@@ -4,18 +4,18 @@ module Interferon
   class WorkHoursHelper
     DEFAULT_WORK_DAYS = (1..5)
     DEFAULT_WORK_HOURS = (9..16)
-    DEFAULT_WORK_TIMEZONE = 'America/Los_Angeles'
+    DEFAULT_WORK_TIMEZONE = 'America/Los_Angeles'.freeze
     DEFAULT_WORK_ARGS = {
-      :hours => DEFAULT_WORK_HOURS,
-      :days => DEFAULT_WORK_DAYS,
-      :timezone => DEFAULT_WORK_TIMEZONE,
+      hours: DEFAULT_WORK_HOURS,
+      days: DEFAULT_WORK_DAYS,
+      timezone: DEFAULT_WORK_TIMEZONE,
     }.freeze
 
     def self.is_work_hour?(time, args = {})
       args = args.merge(DEFAULT_WORK_ARGS)
       tz = TZInfo::Timezone.get args[:timezone]
       time_in_tz = time + tz.period_for_utc(time).utc_offset
-      return args[:days].include?(time_in_tz.wday) && args[:hours].include?(time_in_tz.hour)
+      args[:days].include?(time_in_tz.wday) && args[:hours].include?(time_in_tz.hour)
     end
   end
 end