alert_logic 0.1.1

data/lib/alert_logic/log.rb

@@ -0,0 +1,23 @@
+# Module accessor for logger instance
+module AlertLogic
+  @logger = nil
+
+  # Set or return a logger instance
+  def self.logger(logger_file = nil)
+    if !@logger || logger_file
+      if defined?(Chef::Log.logger) && !logger_file
+        @logger = Chef::Log.logger
+      else
+        @logger = Logger.new(logger_file || $stdout)
+        @logger.level = Logger::INFO
+      end
+    end
+    @logger
+  end
+
+  # Set logger instance to another instance
+  def self.logger=(logger)
+    logger.is_a?(String) ? self.logger(logger) : @logger = logger
+    @logger
+  end
+end

data/lib/alert_logic/resources.rb

@@ -0,0 +1,5 @@
+require 'alert_logic/resources/base_resource'
+require 'alert_logic/resources/filters'
+require 'alert_logic/resources/appliance'
+require 'alert_logic/resources/policy'
+require 'alert_logic/resources/protected_host'

data/lib/alert_logic/resources/appliance.rb

@@ -0,0 +1,6 @@
+module AlertLogic
+  # Generates an Appliance object based on JSON API response.
+  class Appliance
+    include Resource
+  end
+end

data/lib/alert_logic/resources/base_resource.rb

@@ -0,0 +1,123 @@
+module AlertLogic
+  # Common methods that we'll mix into our resource classes
+  module Resource
+    include Utils
+
+    def self.included(klass)
+      klass.extend Resource
+    end
+
+    def find_by_id(id)
+      resource_type = name.split('::').last
+      klass         = AlertLogic.const_get(resource_type.to_sym)
+      resource      = AlertLogic \
+                        .api_client \
+                        .retrieve(resource_type.downcase, id) \
+                        .body \
+                        .first
+      klass.new(resource)
+    end
+
+    def find(*params)
+      resource_type = name.split('::').last
+      options       = params.empty? ? {} : eval_filters(params)
+      klass         = AlertLogic.const_get(resource_type.to_sym)
+      resources     = AlertLogic \
+                        .api_client \
+                        .list(resource_type.downcase, options) \
+                        .body
+      resources.map! { |resource_hash| klass.new(resource_hash) }
+    end
+
+    def initialize(resource_hash)
+      @resource_type = self.class.to_s.downcase.split('::').last
+      objectify(resource_hash)
+    end
+
+    def name=(name)
+      payload = { @resource_type => { 'name' => name } }
+      AlertLogic.api_client.edit(@resource_type, id, payload)
+      reload!
+    end
+
+    def tags=(tags)
+      msg = 'Tags must be a space separated string'
+      fail ClientError, msg unless tags.is_a?(String)
+      tags = tags.split.map! { |tag| { 'name' => tag } }
+      payload = { @resource_type => { 'tags' => tags } }
+      AlertLogic.api_client.edit(@resource_type, id, payload)
+      reload!
+    end
+
+    def reload!
+      objectify(
+        AlertLogic \
+          .api_client \
+          .list(@resource_type, 'id' => id) \
+          .body \
+          .first
+      )
+    end
+
+    private
+
+    def eval_filters(params)
+      filters = Resource.filters
+      unknown_filters = []
+      params = params.map do |param|
+        if param.is_a?(Symbol)
+          if filters.key?(param)
+            filters[param]
+          else
+            unknown_filters << param
+            {}
+          end
+        elsif param.is_a?(Hash)
+          param
+        else
+          {}
+        end
+      end.reduce(&:merge)
+      msg = "Unknown filter(s) passed: #{unknown_filters.inspect}."
+      msg << " Valid filters: #{filters.keys.inspect}"
+      AlertLogic.logger.warn(msg) unless unknown_filters.empty?
+      params
+    end
+
+    # Recursively traverse the hash and create an instance variable and
+    # accessor method for each key/value pair.
+    def objectify(hash)
+      hash.each do |name, value|
+        if value.is_a?(Hash)
+          value = uniquify_keys(name, value)
+          objectify(value)
+        else
+          def_method(name, value)
+        end
+      end
+    end
+
+    # Some hash pairs have similar namespaces.  We want to rename those to
+    # avoid a naming collision.
+    def uniquify_keys(name, hash)
+      conflicts = /^config$|^appliance$|^created$|
+                  ^modified$|^config_policy$|^appliance_policy$/
+      return hash unless name =~ conflicts
+      hash.map { |k, v| { "#{name}_#{k}" => v } }.reduce(&:merge)
+    end
+
+    # create and set an instance variable and define an accessor method if it's
+    # not already there.
+    def def_method(name, value)
+      instance_variable_set("@#{name}", value)
+      # Don't overwrite existing methods unless it's id.  id isnt fully
+      # deprecatedin 1.8.7
+      (return true) if respond_to?(name.to_sym) && name != 'id'
+      self.class.send(
+        :define_method,
+        name,
+        proc { instance_variable_get("@#{name}") }
+      )
+    end
+  end
+end

data/lib/alert_logic/resources/filters.rb

@@ -0,0 +1,22 @@
+module AlertLogic
+  # Resource Filters
+  module Resource
+    @filters = nil
+    # Resource filters accessor
+    def self.filters(filters = nil)
+      defaults = {
+        :ok                   =>  { 'status.status'     => 'ok'       },
+        :online               =>  { 'status.status'     => 'ok'       },
+        :offline              =>  { 'status.status'     => 'offline'  },
+        :error                =>  { 'status.status'     => 'error'    },
+        :windows              =>  { 'metadata.os_type'  => 'windows'  },
+        :linux                =>  { 'metadata.os_type'  => 'unix'     },
+        :unix                 =>  { 'metadata.os_type'  => 'unix'     },
+        :appliance_assignment =>  { 'type'  => 'appliance_assignment' },
+        :all      =>  {}
+      }
+      filters && @filters = filters
+      @filters ||= defaults
+    end
+  end
+end

data/lib/alert_logic/resources/policy.rb

@@ -0,0 +1,6 @@
+module AlertLogic
+  # Generates an Appliance object based on JSON API response.
+  class Policy
+    include Resource
+  end
+end

data/lib/alert_logic/resources/protected_host.rb

@@ -0,0 +1,67 @@
+module AlertLogic
+  # AlertLogic ProtectedHost built from a JSON API response.
+  class ProtectedHost
+    include Resource
+
+    def appliance_policy_id=(policy_id)
+      update_policy('appliance', policy_id)
+    end
+
+    def config_policy_id=(policy_id)
+      update_policy('config', policy_id)
+    end
+
+    def appliance?(appliance)
+      # sometimes appliance_assigned_to wont exist if the Protected Host isn't
+      # already assigned to an appliance.
+      if respond_to?(:appliance_assigned_to)
+        appliance = find_appliance(appliance) if appliance.is_a?(String)
+        appliance.id == appliance_assigned_to
+      else
+        false
+      end
+    end
+
+    def assign_appliance(appliance)
+      if appliance?(appliance)
+        AlertLogic.logger.info 'Host is already assigned to that Appliance'
+      else
+        appliance = find_appliance(appliance) if appliance.is_a?(String)
+        policy = AlertLogic::Policy \
+          .find('type' => 'appliance_assignment') \
+          .select { |pol| pol.appliances.any? { |ap| ap == appliance.id } } \
+          .first
+        self.appliance_policy_id = policy.id
+      end
+    end
+
+    def reload!
+      [:@appliance_assigned_to,
+       :@appliance_connected_to,
+       :@appliance_policy_id,
+       :@config_policy_id
+      ].each do |var|
+        remove_instance_variable(var) if instance_variable_defined?(var)
+      end
+      super
+    end
+
+    private
+
+    def find_appliance(name)
+      msg = "Searching for an appliance with name: #{name}"
+      AlertLogic.logger.info msg
+      Appliance.find.select { |ap| ap.name == name }.first
+    end
+
+    def update_policy(policy_type, policy_id)
+      payload = { 'protectedhost' =>
+        { policy_type => { 'policy' => { 'id' => policy_id } } }
+      }
+      res = AlertLogic.api_client.edit('protectedhost', id, payload)
+      AlertLogic.logger.debug res.body.inspect
+      reload!
+      AlertLogic.logger.info "#{policy_type} policy updated!"
+    end
+  end
+end

data/lib/alert_logic/utils.rb

@@ -0,0 +1,11 @@
+module AlertLogic
+  # common utility methods that are required in multiple classes
+  module Utils
+    private
+
+    # simple string pluralizer to translate singular Alert Logic resources
+    def pluralize(resource)
+      resource =~ /^\w+y$/ ? resource.sub(/y$/, 'ies') : "#{resource}s"
+    end
+  end
+end

data/lib/alert_logic/version.rb

@@ -0,0 +1,4 @@
+# Gem version
+module AlertLogic
+  VERSION = '0.1.1'
+end

data/spec/alert_logic_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module AlertLogic
+  describe AlertLogic, '.api_client' do
+    before(:each) do
+      @client = double(:secret_key => '3234', :endpoint => 'https://fake.com')
+      AlertLogic.instance_variable_set(:@api_client, @client)
+      allow(Client).to receive(:new).and_return(@client)
+    end
+
+    it 'accepts no params and returns a client' do
+      AlertLogic.instance_variable_set(:@api_client, nil)
+      AlertLogic.api_client.should eq(@client)
+    end
+
+    it 'accepts a non-matching secret_key param and returns a new client' do
+      new_key = '8F1E9F714E7C70DADF5C26BDC89618999E211FA45766279f07'
+      Client.should_receive(:new).with(new_key, nil)
+      AlertLogic.api_client(new_key)
+    end
+
+    it 'accepts a matching secret_key param and returns an existing client' do
+      AlertLogic.api_client('3234').should eq(@client)
+    end
+
+    it 'accepts a non-matching endpoint param and returns a new client' do
+      endpoint = 'https://differentfake.com'
+      Client.should_receive(:new).with(nil, endpoint)
+      AlertLogic.api_client(nil, endpoint)
+    end
+
+    it 'accepts a matching endpoint param and returns an existing client' do
+      AlertLogic.api_client(nil, '3234').should eq(@client)
+    end
+
+    it 'accepts a non-matching endpoint/key params and returns a new client' do
+      endpoint = 'https://differentfake.com'
+      new_key = '8F1E9F714E7C70DADF5C26BDC89618999E211FA45766279f07'
+      Client.should_receive(:new).with(new_key, endpoint)
+      AlertLogic.api_client(new_key, endpoint)
+    end
+
+    it 'accepts a matching endpoint param and returns an existing client' do
+      AlertLogic.api_client('https://fake.com', '3234').should eq(@client)
+    end
+  end
+
+  describe AlertLogic, '.secret_key' do
+    before(:each) do
+      AlertLogic.instance_variable_set(:@secret_key, '1234')
+      allow(AlertLogic).to receive(:api_client).with(/\d+/)
+    end
+
+    it 'returns nil when not set' do
+      AlertLogic.instance_variable_set(:@secret_key, nil)
+      AlertLogic.secret_key.should be_nil
+    end
+
+    it 'returns a value when set' do
+      AlertLogic.secret_key.should_not be_nil
+      AlertLogic.secret_key.should eq('1234')
+    end
+
+    it 'configures a new api_client when the key doesnt match' do
+      AlertLogic.should_receive(:api_client).with('5678')
+      AlertLogic.secret_key('5678')
+    end
+
+    it 'returns the existing key when the keys match' do
+      AlertLogic.secret_key('1234').should eq('1234')
+    end
+  end
+
+  describe AlertLogic, '.secret_key=' do
+    it 'should proxy request to #secret_key' do
+      AlertLogic.should_receive(:secret_key)
+      AlertLogic.secret_key = '1234'
+    end
+  end
+end

data/spec/client/base_client_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module AlertLogic
+  describe Client, '.new' do
+    before(:each) do
+      AlertLogic.secret_key = Test.secret_key
+    end
+
+    it 'initializes a new client with no params and a secret_key set' do
+      client = Client.new
+      client.secret_key.should eq(AlertLogic.secret_key)
+    end
+
+    it 'raises an exception when no key is configure or passed' do
+      AlertLogic.secret_key = nil
+      expect { Client.new }.to raise_error(InvalidKey)
+    end
+
+    it 'initializes a new client with a key param' do
+      key = '8F1E9F714E7C70DADF5C26BDC89618999E211FA45766279f07'
+      client = Client.new(key)
+      client.secret_key.should eq(key)
+    end
+
+    it 'initializes a new client with an endpoint param' do
+      endpoint = 'https://fake.com'
+      client = Client.new(nil, endpoint)
+      client.endpoint.should eq(endpoint)
+    end
+
+    it 'initializes a new client with both params' do
+      endpoint = 'https://fake.com'
+      key = '8F1E9F714E7C70DADF5C26BDC89618999E211FA45766279f07'
+      client = Client.new(key, endpoint)
+      client.endpoint.should eq(endpoint)
+      client.secret_key.should eq(key)
+    end
+
+    it 'creates all the required instance variables' do
+      # ruby 1.8.7 can't sort an array of symbols so we have to define <=>
+      # to convert them to strings and compare against an array of strings.
+      vars = ['@secret_key', '@endpoint', '@logger', '@connection']
+      client = Client.new
+      client.instance_variables.map(&:to_s).sort \
+        .should eq(vars.sort)
+      client \
+        .instance_variable_get(:@connection) \
+        .should be_instance_of(Faraday::Connection)
+    end
+  end
+end

data/spec/client/rest_methods_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module AlertLogic
+  describe RestMethods, :env do
+    let(:client) { AlertLogic.api_client(Test.secret_key) }
+
+    Test.all_resources.each do |resource, id|
+      describe '.delete' do
+        it 'interpolates the params and calls the proper client method' do
+          client.should_receive(:delete).with('resource', 'resource_id')
+          client.delete('resource', 'resource_id')
+        end
+      end
+
+      describe '.get' do
+        it 'interpolates the params and calls the proper client method' do
+          client.should_receive(:get).with(resource, id)
+          client.get(resource, id)
+        end
+
+        it "properly parses #{resource} index" do
+          res = client.get(resource, nil)
+          expect(res.body).to be_instance_of(Array)
+          expect(res.status).to eq(200)
+        end
+
+        it "properly parses a singular #{resource}" do
+          res = client.get(resource, id)
+          res.body.first['id'].should eq(id)
+        end
+      end
+
+      describe '.put' do
+        it 'interpolates the params and calls the proper client method' do
+          client.should_receive(:put).with('resource', 'resource_id')
+          client.put('resource', 'resource_id')
+        end
+      end
+
+      describe '.post' do
+        it 'interpolates the params and calls the proper client method' do
+          client.should_receive(:post).with('resource', 'resource_id')
+          client.post('resource', 'resource_id')
+        end
+      end
+    end
+  end
+end