xcal-parktronic 0.0.1 → 1.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTRjMTNmYzgwYWZmNTYzZDQ4NmJkZTBjOTE3OTg1ZTE0ZjA2ZDJhOA==
+    ZGJhY2FjMDA3YzIwYWY2ZGVjN2IwNTliNmJjMWNjZTZjYmU3NGU0Nw==
   data.tar.gz: !binary |-
-    OTllOTViZWE1ODMyZTRmMGQ2YTRjYjBiZWE4NDNiY2JmYWYwNDc2Zg==
+    NmE2MzU3Mzk2NWJiZjk2ZTkxOWRhYzk4ZWE4OWM0NmM4MWVlNTE0Zg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OTg4NGU4YWU2OTZhZDVjOWUyOWY0ZGQyNzE1NmJlZDg2ZWU4MWI0MWQ0NGFi
-    Mjc2OTZjMDg0NWY1NTkzOGE5ZDhiNDlhMjcxYWU2MmU4ZjFmNTI3ZTJmZGE1
-    Njg3NmI5YjhjNTAyMmU1YmNmYTFlOTVhYWI5NTFjNjVlZDA5OWU=
+    ZDAxMzYyMTk1ZDM0MTg3MzkwNDVjNjg4YjMwYTA0M2UzNzhkZWJkM2Q1MTVj
+    ZWExNWZmNmZkYWU0YzJiNmYyZTI3ODk5ZjViOTE1YzI3OTFlNDkxY2RlOWM0
+    Mzg0YmJlZGRkYWE5YjkyMzZmNmRjNzE1YzBlYWZmMDY1YjJlZGU=
   data.tar.gz: !binary |-
-    NTNjM2QwOGNmZDg4MTM5YTU5Yjk5NTQ4MzlkZjkzNzY0YTM4Yzk4MjBiZGFk
-    NzQ5ZmZlYmNmZWE0NWUwNzZkODBkZDQzYTYzNDE5ZjVmYmExN2VkZTU1OTdl
-    NzY3MTU5ZmVjMzk3NzcxM2NmYWRmNGI3OGUyNTg0MWJkOGJmYzY=
+    NjU4MTI5YTliN2RiM2QzZGQxZTVmMDg0MzE3M2JmNDc1NDFlMWRkMDkyNDk5
+    NTIxYzdhMDVlZmMyMWYyNTJiOWVkOTE1NDM2Y2U5YmY4ZGI2MjA3YzkwYTU0
+    YjFkZjY2ODFkZWVjYjE4MDViNDc4ODQyYjMzMzBmZDlkNzg5ODU=

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+script: "bundle exec rake test"
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/README.md

@@ -1,3 +1,6 @@
+
+[![Build Status](https://api.travis-ci.org/Ser1aL/xcal-parktronic.png?branch=master)](http://travis-ci.org/Ser1aL/xcal-parktronic)
+
 # Xcal::Parktronic
 
 TODO: Write a gem description
@@ -16,14 +19,77 @@ Or install it yourself as:
 
     $ gem install xcal-parktronic
 
+## RDocs
+
+You can view documentation in RDoc format here:
+
+http://rubydoc.info/gems/xcal-parktronic/frames
+
 ## Usage
 
-TODO: Write usage instructions here
+# Initialization:
+
+```ruby
+api = Xcal::Parktronic::ApiClient.new(access_token: 'your_access_token', endpoint: 'http://api_host')
+```
+
+# Alarms:
+```ruby
+api.alarms
+api.alarm_tags(1)
+api.search_alarm(name: 'test', tagged_with: 'test', time_range: 24, originating_system: 'Splunk', page: 1, per_page: 20)
+```
+
+# Outages:
+```ruby
+api.outages
+api.outages(page: 2, per_page: 5)
+```
+
+# Stack changes
+```ruby
+api.stack_changes
+api.stack_changes(page: 2, per_page: 5)
+api.stack_changes(page: 2, per_page: 5, element: 'XBO')
+api.stack_changes(time_range: {time_offset: -1, start_date: 0, start_time: 1440, end_time: 0}, element: 'XBO')
+```
+
+# Events history
+```ruby
+api.events_history
+api.events_history(page: 2, per_page: 5)
+api.events_history(host_impacted: 'xre-host-1', service_impacted: 'xre')
+```
+
+# Command notifications (remote commands)
+```ruby
+api.command_notifications
+api.command_notifications(page: 1, per_page: 2)
+api.update_command_notification(10)
+```
+
+# Events
+```ruby
+api.add_event
+api.update_event
+api.event_tags(1)
+api.alarm(3).get_all_events
+api.alarm(3).post_event(data)
+```
 
-## Contributing
+# Alarm Actions
+```ruby
+api.alarm(3).get_alarm_actions
+api.alarm(3).get_alarm_action(alarm_action_id)
+api.alarm(3).post_alarm_action
+api.alarm(3).update_alarm_action
+api.alarm(3).set_position
+```
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+# Custom Queries
+```ruby
+api.get_custom_queries
+api.post_custom_query
+api.update_custom_query
+api.find_custom_query
+```

data/lib/xcal/parktronic.rb

@@ -11,6 +11,17 @@ require 'hashie'
 
 # each route then common Routes module
 require 'xcal/parktronic/routes/alarms'
+require 'xcal/parktronic/routes/events'
+require 'xcal/parktronic/routes/nested/events'
+require 'xcal/parktronic/routes/metrics'
+require 'xcal/parktronic/routes/custom_queries'
+require 'xcal/parktronic/routes/nested/alarm_actions'
+require 'xcal/parktronic/routes/nested/metric_values'
+require 'xcal/parktronic/routes/nested/device_errors'
+require 'xcal/parktronic/routes/outages'
+require 'xcal/parktronic/routes/stack_changes'
+require 'xcal/parktronic/routes/event_history_items'
+require 'xcal/parktronic/routes/command_notifications'
 require 'xcal/parktronic/routes'
 
 # exceptions

data/lib/xcal/parktronic/api_client.rb

@@ -7,13 +7,16 @@ module Xcal
 
       # API Client initialization.
       #
-      # Acceptable attributes:
-      #   +endpoint+ - OIV endpoint
-      #   +proxy+ - enables proxy if proxy url is passed
-      #   +access_token+ - access key to application
-      #   +version+ - api version. defaults to v1
+      # ==== Parameters
+      # *  +endpoint+ - OIV endpoint
+      # *  +proxy+ - enables proxy if proxy url is passed
+      # *  +access_token+ - access key to application
+      # *  +version+ - api version. defaults to v1
+      # ==== Examples
+      # api = Xcal::Parktronic::ApiClient.new(access_token: 'your_access_token', endpoint: 'http://api-host.com')
       def initialize(args)
         @args = args
+        @args.default_proc = proc{|h, k| h.key?(k.to_s) ? h[k.to_s] : nil}
       end
 
       def host

data/lib/xcal/parktronic/generic_response.rb

@@ -4,11 +4,19 @@ module Xcal
     class GenericResponse
       include Exceptions
 
+      # define all nested routes here
+      include Routes::Nested::Events
+      include Routes::Nested::DeviceErrors
+      include Routes::Nested::MetricValues
+      include Routes::Nested::AlarmActions
+
+      attr_reader :client
+
       # Generic Response initializations
       #
       # Accepted attributes are:
       #   +raw_response+ should be a hash or a valid raw JSON string
-      def initialize(raw_response = nil)
+      def initialize(raw_response = nil, client = nil)
         # nil input
         raise InvalidResponseArgument.new('Cannot create response object without raw response') if raw_response.nil?
 
@@ -28,12 +36,20 @@ module Xcal
         end
 
         @source = Hashie::Mash.new(@source)
+        @client = client
+      end
+
+      def has_key?(key)
+        @source.has_key?(key)
       end
 
       def method_missing(*args)
-        # deep inject itself into the each object of the hash
+        # verify key in hashed self first
         if @source.has_key?(args.first)
           @source[args.first]
+        # verify key in nested routes
+        elsif respond_to?(args.first)
+          send args.first
         else
           raise NoMethodError, "undefined method `#{args.first}' for #{self.class}"
         end

data/lib/xcal/parktronic/routes.rb

@@ -2,8 +2,15 @@ module Xcal
   module Parktronic
 
     module Routes
-      # include all available routes here
+      # include top-level routes here
       include Alarms
+      include Metrics
+      include Events
+      include Outages
+      include StackChanges
+      include EventHistoryItems
+      include CommandNotifications
+      include CustomQueries
     end
   end
-end
+end

data/lib/xcal/parktronic/routes/alarms.rb

@@ -6,72 +6,153 @@ module Xcal
 
         # Fetches latest alarms
         #
-        # Accepted attributes:
-        #   +page+ set page, defaults to 1
-        #   +per_page+ set per page value, defaults to 10
+        # ==== Parameters
+        # * +page+ page number, defaults to 1
+        # * +per_page+ per page value, defaults to 100
+        #
+        # ==== Examples
+        #   api.get_paged_alarms
+        #   api.get_paged_alarms(page: 2, per_page: 5)
+        #   api.alarms
+        #   api.alarms(page: 2, per_page: 5)
         def get_paged_alarms(args = {})
           args.merge!(:access_token => access_token)
           response = http.get("/#{api_version}/alarms?#{URI.encode_www_form(args)}")
 
           generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
-          response.code == '200' ? generic_response.alarms.map(&:alarm) : generic_response
+          if response.code == '200'
+            generic_response.alarms.map { |alarm| Xcal::Parktronic::GenericResponse.new(alarm.alarm, self) }
+          else
+            generic_response
+          end
 
           # TODO Add caching
         end
         alias :alarms :get_paged_alarms
 
-
         # Fetches alarm with specific ID
         #
-        # Accepted attributes:
-        # +id+ alarm ID
+        # ==== Parameters
+        # * +id+ alarm ID
+        #
+        # ==== Examples
+        #   api.get_alarm(2)
         def get_alarm(id)
           response = http.get("/#{api_version}/alarms/#{id}?access_token=#{access_token}")
 
           generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
-          response.code == '200' ? generic_response.alarm : generic_response
+          response.code == '200' ? Xcal::Parktronic::GenericResponse.new(generic_response.alarm, self) : generic_response
 
           # TODO Add caching
         end
         alias :alarm :get_alarm
 
+
         # Posts new alarm
         #
-        # Alarm argument should be a hash of Alarm + Events data.
+        # ==== Parameters
+        # * +alarm+ hash of Alarm data.
+        # * +events+ array of Events or leave blank for creating alarm without events.
         #
-        # Example of alarm data:
-        #
-        #    +alarm+ :
-        #    {
-        #      :name => 'alarm name',
-        #      :originating_system => 'Source System',
-        #      :impact_level => 'low',
-        #      :tag_list => %w(taga tagb)
-        #    }
+        # ==== Examples
+        #   # Creates only Alarm, without Events
+        #   api.post_alarm(alarm: {name: 'alarm name', originating_system: 'Source System', impact_level: 'low'})
+        #   # Creates Alarm with Events
+        #   alarm_params    = {name: 'alarm name', originating_system: 'Source System', impact_level: 'low'}
+        #   event_1_params  = {subject: 'EventSubj', description: 'EventDesc', host_impacted: 'host', initiated_at: '2013-11-22T01:00:24Z', service_impacted: 'EventSvc', incident_status: 'CRITICAL'}
+        #   api.post_alarm( alarm: alarm_params, events: [event_1_params, event_2_params, ...] )
+        def post_alarm(args = {})
+          url_path  = args[:events].nil? ? 'alarms/create_without_events' : 'alarms'
+          request   = Net::HTTP::Post.new("/#{api_version}/#{url_path}", 'Content-Type' => 'application/json')
+
+          params    = { access_token: access_token, alarm: args[:alarm] }
+          params.merge!(events: args[:events]) unless args[:events].nil?
+
+          request.body = params.to_json
+          response = http.start { |net| net.request(request) }
+
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+
+        # Update alarm with specific ID
         #
-        # Example of events array:
-        #    +events+ :
-        #    [
-        #      {
-        #        :subject => 'EventSubj',
-        #        :description => 'EventDesc',
-        #        :host_impacted => 'host',
-        #        :initiated_at => '2013-11-22T01:00:24Z',
-        #        :service_impacted => 'EventSvc',
-        #        :incident_status => 'CRITICAL'
-        #      }
-        #    ]
+        # ==== Parameters
+        # * +id+ alarm ID
+        # * +params+ alarm params
         #
-        def post_alarm(alarm = {}, events = [])
-          request = Net::HTTP::Post.new("/#{api_version}/alarms", 'Content-Type' => 'application/json')
-          request.body = { access_token: access_token, alarm: alarm, events: events }.to_json
-          response = http.start { |net| net.request(request) }
+        # ==== Examples
+        #   api.update_alarm(2, name: 'new name')
+        #   api.update_alarm(5, name: 'new name', originating_system: 'new system', description: 'test')
+        def update_alarm(id, params)
+          request = Net::HTTP::Patch.new("/#{api_version}/alarms/#{id}", 'Content-Type' => 'application/json')
+          request.body = { access_token: access_token, alarm: params }.to_json
 
+          response = http.start { |net| net.request(request) }
           Xcal::Parktronic::GenericResponse.new(response.body)
         end
 
       end
 
+      # Find all Alarm Tags
+      #
+      # ==== Parameters
+      # * +id+ alarm ID
+      #
+      # ==== Examples
+      #   api.get_alarm_tags(2)
+      #   api.alarm_tags(2)
+      def get_alarm_tags(id)
+        response = http.get("/#{api_version}/alarms/#{id}/tags?#{URI.encode_www_form(access_token: access_token)}")
+
+        generic_response = Xcal::Parktronic::GenericResponse.new(response.body, self)
+        response.code == '200' && generic_response.has_key?(:tags) ? generic_response.tags.map(&:tag) : generic_response
+      end
+      alias :alarm_tags :get_alarm_tags
+
+      # Search unclosed alarm by name or tag or originating system with time range
+      #
+      # ==== Parameters
+      # * +name+ string, alarm name
+      # * +tagged_with+ string or array, tag list
+      # * +time_range+ integer, time range in hours, defaults to 24 hours
+      # * +originating_system+ string or array, originating system name(s), blank by default (example: 'Op5_Nagios' or 'Op5_Nagios Splunk' or ['Op5_Nagios', 'Splunk'])
+      # * +page+ integer, page number, defaults to 1
+      # * +per_page+ integer, per page value, defaults to 100
+      #
+      # ==== Examples
+      #   api.search_alarm(name: 'test alarm')
+      #   api.search_alarm(tagged_with: 'test alarm', time_range: 120)
+
+      def search_alarm(args = {})
+        custom_extends = [ 'latest_event', 'latest_unclosed_event' ]
+        custom_scopes  = { with_most_recent_events: [] }
+
+        #Filter
+        filter = { alarms: '' }
+        custom_filter = args[:originating_system]
+        custom_filter = custom_filter.split(' ') if custom_filter.is_a?(String)
+        filter = { alarms: custom_filter.map{|os| "originating_system = '#{os}'"}.join(' OR ') } unless custom_filter.nil?
+
+        #Scopes (time range)
+        custom_scopes[:within_event_date_range] = [(Time.now - (60 * (60 * args.fetch(:time_range, 24)))).strftime('%Y-%m-%d %H:%M:%S'), Time.now.strftime('%Y-%m-%d %H:%M:%S')]
+
+        #Tags
+        custom_scopes[:tagged_with] = args[:tagged_with] unless args[:tagged_with].nil?
+
+        # Params for request
+        scopes    = URI.escape(custom_scopes.to_json)
+        search    = URI.escape({name: args.fetch(:name, '')}.to_json)
+        extends   = URI.escape(args.fetch(:extends, custom_extends).to_json)
+        filter    = URI.escape(args.fetch(:filter, filter).to_json)
+        page      = args.fetch(:page, 1)
+        per_page  = args.fetch(:per_page, 100)
+
+        response = http.get("/#{api_version}/alarms/search?page=#{page}&per_page=#{per_page}&scopes=#{scopes}&search=#{search}&extends=#{extends}&filter=#{filter}&access_token=#{access_token}")
+
+        generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+        response.code == '200' && generic_response.has_key?(:alarms) ? generic_response.alarms.map(&:alarm) : generic_response
+      end
+
     end
   end
 end

data/lib/xcal/parktronic/routes/command_notifications.rb

@@ -0,0 +1,56 @@
+module Xcal
+  module Parktronic
+    module Routes
+
+      module CommandNotifications
+
+        # Fetches remote commands
+        #
+        # ==== Parameters
+        # * +page+ page number, defaults to 1
+        # * +per_page+ per page value, defaults to 100
+        #
+        # ==== Examples
+        #   api.get_paged_command_notifications
+        #   api.command_notifications
+        def get_paged_command_notifications(args = {})
+          args.merge!(access_token: access_token)
+          response = http.get("/#{api_version}/command_notifications?#{URI.encode_www_form(args)}")
+
+          generic_response = Xcal::Parktronic::GenericResponse.new(response.body)
+          if response.code == '200' && generic_response.has_key?(:remote_commands)
+            generic_response.remote_commands.map { |command| Xcal::Parktronic::GenericResponse.new(command.remote_command, self) }
+          else
+            generic_response
+          end
+
+          # TODO Add caching
+        end
+        alias :command_notifications :get_paged_command_notifications
+
+
+        # Set inactive remote command
+        #
+        # ==== Parameters
+        # * +id+ remote command ID
+        #
+        # ==== Examples
+        #   api.update_command_notification(1)
+        #   api.set_inactive_command_notification(1)
+        def update_command_notification(id)
+          begin
+            request = Net::HTTP::Patch.new("/#{api_version}/command_notifications/#{id}", 'Content-Type' => 'application/json')
+          rescue # ruby 1.9.2
+            request = Net::HTTP::Put.new("/#{api_version}/command_notifications/#{id}", 'Content-Type' => 'application/json')
+          end
+          request.body = { access_token: access_token }.to_json
+
+          response = http.start { |net| net.request(request) }
+          Xcal::Parktronic::GenericResponse.new(response.body)
+        end
+        alias :set_inactive_command_notification :update_command_notification
+      end
+
+    end
+  end
+end