ocular 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de167ed33e75bba8f6482de164f5b1f7c1fea60a
+  data.tar.gz: f9ce4d9717736477221e9a456bfafcd1d6a4d0f9
+SHA512:
+  metadata.gz: 260602dd6cef56943d98f5a6271dfd5cded3753a222c1e14d3ba6eb437e45e048f1074b63a09e6e18684c415aeb1856a0dc8837680c1f0b512cf0f078e2b637f
+  data.tar.gz: 84e6e806f943dff204d98a39dcf125dbf9a8cf61f7db2f1a0c5b53c2bcb5a7afe6f1fa28e1c68cd9c739a5d9732b7e51b73b12c796d6ad095a8c305ed38215e2

data/README.md

@@ -0,0 +1,15 @@
+# ocular
+Framework to automate responses for infrastructure events.
+
+Ocular allows to easily create small scripts which are triggered from multiple different event sources and which can then execute scripts commanding all kinds of infrastructure, do remote command execution, execute AWS API calls, modify databases and so on.
+
+The goal is that a new script could be written really quickly to automate a previously manual infrastructure maintenance job instead of doing the manual job yet another time. Scripts are written in Ruby with a simple Ocular DSL which allows the script to easily respond to multitude different events.
+
+Planned event sources:
+ - HTTP calls
+ - RabbitMQ messages
+ - SQS/SNS messages
+ - Graphite item triggers
+ - Zabbix alerts
+ - Timers
+ 

data/examples/ssh-example.rb

@@ -0,0 +1,11 @@
+require 'pp'
+
+onEvent nil do
+    asdf("localhost")
+end
+
+def asdf(host)
+    r = ssh_to(host)
+    pp r.execute("ls")
+end
+

data/lib/blocktest.rb

@@ -0,0 +1,40 @@
+# game.rb
+
+module MixinTest
+
+    def setMixingTestValue(val)
+        @mixingTestValue = val
+    end
+
+    def getMixingTestValue
+        return @mixingTestValue
+    end
+
+end
+
+class BlockTest
+
+    attr_accessor :testValue
+
+    include MixinTest
+
+    def initialize(&block)
+        @callback = block
+    end
+
+    def testMethod(val)
+        @testValue = val
+    end
+
+    def call(&block)
+        block.call
+    end
+
+    def ieval(&block)
+        self.instance_eval(&block)
+    end
+
+    def ievaldef
+        self.instance_eval(&@callback)
+    end
+end

data/lib/ocular.rb

@@ -0,0 +1,2 @@
+
+require 'ocular/ocular.rb'

data/lib/ocular/dsl/logging.rb

@@ -0,0 +1,117 @@
+require 'logger'
+
+class Ocular
+    module DSL
+        module Logging
+
+            def debug(message = nil, &block)
+                @logger.add(Logger::Severity::DEBUG, message, @run_id, &block)
+            end
+            alias log debug
+
+            def info(message = nil, &block)
+                add(Severity::INFO, nil, message, &block)
+            end
+
+            def warn(message = nil, &block)
+                add(Severity::INFO, nil, message, &block)
+            end
+
+            def error(message = nil, &block)
+                add(Severity::INFO, nil, message, &block)
+            end
+
+            def fatal(message = nil, &block)
+                add(Severity::INFO, nil, message, &block)
+            end
+
+
+        end
+
+        # Most of the Logger class is copied from the Ruby Logger class source code.
+        class Logger
+
+            # Logging severity.
+            module Severity
+                # Low-level information, mostly for developers.
+                DEBUG = 0
+                # Generic (useful) information about system operation.
+                INFO = 1
+                # A warning.
+                WARN = 2
+                # A handleable error condition.
+                ERROR = 3
+                # An unhandleable error that results in a program crash.
+                FATAL = 4
+                # An unknown message that should always be logged.
+                UNKNOWN = 5
+            end
+
+            def initialize()
+                @level = Severity::DEBUG
+                @formatter = Logger::Formatter.new
+            end            
+
+            def add(severity, message = nil, run_id = nil, &block)
+                severity ||= Severity::UNKNOWN
+                if severity < @level
+                    return true
+                end
+
+                if message.nil?
+                    if block_given?
+                        message = yield
+                    else
+                        message = progname
+                    end
+                end
+    
+                puts format_message(format_severity(severity), Time.now, run_id, message)
+                true
+            end
+
+            SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY).each(&:freeze).freeze
+
+            def format_severity(severity)
+                SEV_LABEL[severity] || 'ANY'
+            end            
+
+            def format_message(severity, datetime, progname, msg)
+                @formatter.call(severity, datetime, progname, msg)
+            end
+
+            # Default formatter for log messages.
+            class Formatter
+                Format = "%s, [%s#%d] %5s -- %s: %s\n".freeze
+
+                attr_accessor :datetime_format
+
+                def initialize
+                    @datetime_format = nil
+                end
+
+                def call(severity, time, progname, msg)
+                    Format % [severity[0..0], format_datetime(time), $$, severity, progname, msg2str(msg)]
+                end
+
+            private
+
+                def format_datetime(time)
+                    time.strftime(@datetime_format || "%Y-%m-%dT%H:%M:%S.%6N ".freeze)
+                end
+
+                def msg2str(msg)
+                    case msg
+                    when ::String
+                        msg
+                    when ::Exception
+                        "#{ msg.message } (#{ msg.class })\n" <<
+                        (msg.backtrace || []).join("\n")
+                    else
+                        msg.inspect
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/ocular/dsl/runcontext.rb

@@ -0,0 +1,28 @@
+
+require 'securerandom'
+
+class Ocular
+    module DSL
+        class RunContext
+            attr_accessor :run_id
+            attr_accessor :proxy
+            attr_accessor :class_name
+
+            include Ocular::DSL::Logging
+            include Ocular::DSL::SSH
+
+            def initialize
+                @run_id = SecureRandom.uuid()
+                @logger = Ocular::DSL::Logger.new
+            end
+
+            def method_missing(method_sym, *arguments, &block)
+                if self.proxy
+                    self.proxy.send(method_sym, *arguments, &block)
+                else
+                    raise NoMethodError("undefined method `#{method_sym}` in event #{self.class_name}")
+                end
+            end
+        end
+    end
+end

data/lib/ocular/dsl/ssh.rb

@@ -0,0 +1,16 @@
+require 'logger'
+require 'rye'
+
+class Ocular
+    module DSL
+        module SSH
+
+            def ssh_to(hostname)
+                rbox = ::Rye::Box.new(hostname, :safe => false, :password_prompt => false)
+                return rbox
+            end
+
+        end
+
+    end
+end

data/lib/ocular/event/eventbase.rb

@@ -0,0 +1,28 @@
+require 'ocular/mixin/from_file'
+require 'ocular/dsl/ssh'
+require 'ocular/dsl/logging'
+
+class Ocular
+    module DSL
+
+        class EventBase
+            include Ocular::DSL::SSH
+            include Ocular::DSL::Logging
+
+            attr_accessor :proxy
+
+
+            def initialize(&block)
+              @callback = block
+            end
+
+            def exec(run_context)
+                puts "Running #{run_context}"
+                run_context.proxy = self.proxy
+                run_context.instance_eval(&@callback)
+            end
+
+        end
+    end
+end
+

data/lib/ocular/event/eventfactory.rb

@@ -0,0 +1,47 @@
+require 'ocular/event/eventbase.rb'
+
+class Ocular
+    module Event
+        class DefinitionProxy
+          attr_accessor :events
+          attr_accessor :klass_name
+
+          def initialize(klass_name)
+            self.klass_name = klass_name
+            @events = []
+            @logger = Ocular::DSL::Logger.new
+          end
+
+          include Ocular::Mixin::FromFile
+          include Ocular::DSL::Logging
+
+          def onEvent(factory_class, &block)
+            eventbase = Ocular::DSL::EventBase.new(&block)
+            eventbase.proxy = self
+            @events << eventbase
+          end
+        end
+
+        class EventFactory
+
+            def initialize
+                @files = {}
+            end
+            
+            def load_from_file(file)
+                proxy = DefinitionProxy.new(file)
+                proxy.from_file(file)
+                @files[file] = proxy
+                return proxy
+            end
+
+            def load_from_block(name, &block)
+                proxy = DefinitionProxy.new(name)
+                proxy.instance_eval(&block)
+                @files[name] = proxy
+                return proxy
+            end
+
+        end
+    end
+end

data/lib/ocular/mixin/from_file.rb

@@ -0,0 +1,49 @@
+#
+# OriginalAuthor:: Adam Jacob (<adam@opscode.com>)
+# OriginalAuthor:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+class Ocular
+  module Mixin
+    module FromFile
+
+      # Loads a given ruby file, and runs instance_eval against it in the context of the current
+      # object.
+      #
+      # Raises an IOError if the file cannot be found, or is not readable.
+      def from_file(filename)
+        if File.exists?(filename) && File.readable?(filename)
+          self.instance_eval(IO.read(filename), filename, 1)
+        else
+          raise IOError, "Cannot open or read #{filename}!"
+        end
+      end
+
+      # Loads a given ruby file, and runs class_eval against it in the context of the current
+      # object.
+      #
+      # Raises an IOError if the file cannot be found, or is not readable.
+      def class_from_file(filename)
+        if File.exists?(filename) && File.readable?(filename)
+          self.class_eval(IO.read(filename), filename, 1)
+        else
+          raise IOError, "Cannot open or read #{filename}!"
+        end
+      end
+
+    end
+  end
+end

data/lib/ocular/ocular.rb

@@ -0,0 +1,7 @@
+
+require 'ocular/version'
+require 'ocular/event/eventbase'
+require 'ocular/event/eventfactory'
+require 'ocular/dsl/logging'
+require 'ocular/dsl/ssh'
+require 'ocular/dsl/runcontext'

data/lib/ocular/version.rb

@@ -0,0 +1,3 @@
+class Ocular
+    Version = "0.1.1"
+end

data/spec/blocktest_spec.rb

@@ -0,0 +1,70 @@
+#require_relative "../lib/game.rb"
+require 'blocktest'
+
+def globalMethodForTesting(val)
+    $globalMethodVariable = val
+end
+
+RSpec.describe BlockTest do
+    describe "#call" do
+        it "can call a block" do
+            test = BlockTest.new
+            a = false
+            test.call do
+                a = true
+            end
+            expect(a).to eq(true)
+        end
+    end
+
+    describe "#ieval" do
+        it "can instance_eval a block" do
+            test = BlockTest.new
+            a = false
+            test.ieval do
+                a = true
+            end
+            expect(a).to eq(true)
+        end
+
+        it "can call a BlockTest method" do
+            test = BlockTest.new
+            test.ieval do
+                testMethod(2)
+            end
+            expect(test.testValue).to eq(2)
+        end
+
+        it "can call a BlockTest method while calling global methods" do
+            test = BlockTest.new
+            test.ieval do
+                globalMethodForTesting(3)
+            end
+            expect($globalMethodVariable).to eq(3)
+        end
+
+        it "can call a mixin function" do
+            test = BlockTest.new
+            test.ieval do
+                setMixingTestValue(6)
+            end
+            expect(test.getMixingTestValue).to eq(6)
+        end        
+    end
+
+    describe "#ievaldef" do
+        it "can execute callback from initialise" do
+            a = false
+            test = BlockTest.new do
+                a = true
+            end
+            test.ievaldef
+            expect(a).to eq(true)
+
+
+        end
+
+    end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__) + '../lib')
+
+RSpec.configure do |config|
+    config.color = true
+end
+

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: ocular
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Juho Mäkinen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rye
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.13
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: |+
+  Framework to automate responses for infrastructure events.
+
+  Ocular allows to easily create small scripts which are triggered from multiple different event sources and which can then execute scripts commanding all kinds of infrastructure, do remote command execution, execute AWS API calls, modify databases and so on.
+
+  The goal is that a new script could be written really quickly to automate a previously manual infrastructure maintenance job instead of doing the manual job yet another time. Scripts are written in Ruby with a simple Ocular DSL which allows the script to easily respond to multitude different events.
+
+email: juho@unity3d.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- examples/ssh-example.rb
+- lib/blocktest.rb
+- lib/ocular.rb
+- lib/ocular/dsl/logging.rb
+- lib/ocular/dsl/runcontext.rb
+- lib/ocular/dsl/ssh.rb
+- lib/ocular/event/eventbase.rb
+- lib/ocular/event/eventfactory.rb
+- lib/ocular/mixin/from_file.rb
+- lib/ocular/ocular.rb
+- lib/ocular/version.rb
+- spec/blocktest_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/garo/ocular
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Tool to create simple operational scripts
+test_files: []