ocular 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44118cd5f02b3dc8ef6388b180368295a0d9fa33
-  data.tar.gz: f9742f999a9dee9e10afcc0b1fde77c91dd7a0b3
+  metadata.gz: 80d3eab4870432f28e3a67ed391012aa4cbd0d3d
+  data.tar.gz: d899c2f9ec2020c3d18bf82dc61543bbb8e1163c
 SHA512:
-  metadata.gz: e394d8d393db01c4fe7e3d00e57a29b8150eff97eb495c61897f4b00e3bebac985f82931060a08821d2d4230e23990f2d4a85c5a592e7625c2fb6e9366ba890f
-  data.tar.gz: a4d83f22add7eeefda8f3bfb36ad3e6016b981b8c20574982efe94a9d661e0f418eba0ce0eac000ed9ee62f2301d51c3b6ba5e09926c07ac0140f092a5685e88
+  metadata.gz: b51e2835fb8aa855eeb85a342782d6e0d7c2e7a5b8293f0fe4aaae6c135727a82952a8b4fd85296eec3f5f3802175d6db511274097f6eaebc1a063e9d82282a1
+  data.tar.gz: c8a79305a5259ea4d6f782a81c91ea41c918910603105d885db97cc2b39d14f1a74a326d2a8584b1e26254e0fdb58475cdf7088535b6aef10b5a71d95efd22ae

data/bin/ocular

@@ -21,7 +21,7 @@ class OptparseExample
     options.transfer_type = :auto
     options.verbose = false
     options.server = false
-    options.settings = "~/.ocular.yaml"
+    options.settings = nil
     options.root = nil
 
     opt_parser = OptionParser.new do |opts|
@@ -55,7 +55,7 @@ class OptparseExample
         options.root = path
       end
 
-      opts.on("--settings FILE", "Full path and file name to the settings yaml file. Default: #{options.settings}") do |path|
+      opts.on("--settings FILE", "Full path and file name to the settings yaml file.") do |path|
         options.settings = path
       end
 
@@ -69,7 +69,7 @@ end  # class OptparseExample
 
 options = OptparseExample.parse(ARGV)
 
-Ocular::Settings.load_from_file(File.expand_path(options.settings))
+Ocular::Settings.load_from_file(Ocular::Settings.find_settings_file_from_system(options.settings))
 
 if options.server
   if !options.root && !Ocular::Settings.get(:script_root)
@@ -96,7 +96,7 @@ else
   proxy = ef.load_from_file(ARGV.shift)
 
   context = Ocular::DSL::RunContext.new
-  eventbase = proxy.events[0]
+  eventbase = proxy.events["onEvent"][nil]
   eventbase.exec(context)
 
 end

data/lib/ocular/dsl/fog.rb

@@ -27,6 +27,19 @@ class Ocular
                     })
             end
 
+            def find_servers_in_autoscaling_groups(substring)
+                instances = []
+                for group in autoscaling.groups
+                    if group.id.include?(substring)
+                        for i in group.instances
+                            instances << aws.servers.get(i.id)
+                        end
+                    end
+                end
+
+                return instances
+            end
+
         end
 
     end

data/lib/ocular/dsl/runcontext.rb

@@ -7,6 +7,7 @@ class Ocular
             attr_accessor :run_id
             attr_accessor :proxy
             attr_accessor :class_name
+            attr_accessor :event_signature
 
             include Ocular::DSL::Logging
             include Ocular::DSL::SSH
@@ -14,6 +15,7 @@ class Ocular
             def initialize
                 @run_id = SecureRandom.uuid()
                 @logger = Ocular::DSL::Logger.new
+                @cleanups = []
             end
 
             def method_missing(method_sym, *arguments, &block)
@@ -23,6 +25,16 @@ class Ocular
                     raise NoMethodError("undefined method `#{method_sym}` in event #{self.class_name}")
                 end
             end
+
+            def register_cleanup(&block)
+                @cleanups << block
+            end
+
+            def cleanup()
+                for i in @cleanups
+                    i.call()
+                end
+            end
         end
     end
 end

data/lib/ocular/event/eventbase.rb

@@ -7,20 +7,63 @@ class Ocular
     module DSL
 
         class EventBase
-            include Ocular::DSL::SSH
-            include Ocular::DSL::Fog
-            include Ocular::DSL::Logging
 
-            attr_accessor :proxy
+            class Results
+                attr_accessor :response
+                attr_accessor :error
+            end
 
+            attr_accessor :proxy
 
             def initialize(&block)
-              @callback = block
+                @callback = block
+            end
+
+            def exec(context, do_fork = self.proxy.do_fork)
+                context.proxy = self.proxy
+                if do_fork
+                    return exec_fork(context)
+                else
+                    return exec_nofork(context)
+                end
+            end
+
+            def exec_fork(context)
+                reader, writer = IO::pipe
+                child_pid = fork do
+                    reader.close
+                    r = Results.new
+
+                    begin
+                        retval = context.instance_eval(&@callback)
+
+                        # This check is to make sure that whatever we return that it can be serialised
+                        if String === retval or Array === retval
+                            r.response = retval
+                        end
+
+                    rescue Exception => error
+                        r.error = error
+                    end
+
+                    response_data = Marshal.dump(r)
+                    writer.puts(response_data)
+                    writer.close
+                end
+                writer.close
+
+                Process.wait(child_pid)
+                r = Marshal.load(reader.read)
+                reader.close
+
+                if r.error
+                    raise r.error
+                end
+                return r.response
             end
 
-            def exec(run_context)
-                run_context.proxy = self.proxy
-                run_context.instance_eval(&@callback)
+            def exec_nofork(context)
+                return context.instance_eval(&@callback)
             end
 
         end

data/lib/ocular/event/eventfactory.rb

@@ -6,14 +6,15 @@ class Ocular
     module Event
         class DefinitionProxy
             attr_accessor :events
-            attr_reader :script_name
-            attr_accessor :handlers
+            attr_reader :script_name, :do_fork
+            attr_accessor :handlers, :events
 
             def initialize(script_name, handlers)
                 @script_name = script_name
-                @events = []
+                @events = {}
                 @logger = Ocular::DSL::Logger.new
                 @handlers = handlers
+                @do_fork = true
             end
 
             include Ocular::Mixin::FromFile
@@ -22,10 +23,14 @@ class Ocular
             include Ocular::DSL::Fog
             include Ocular::Inputs::HTTP::DSL
 
-            def onEvent(factory_class, &block)
+            def fork(value)
+                @do_fork = value
+            end
+
+            def onEvent(type, &block)
                 eventbase = Ocular::DSL::EventBase.new(&block)
                 eventbase.proxy = self
-                @events << eventbase
+                (@events["onEvent"] ||= {})[type] = eventbase
             end
         end
 

data/lib/ocular/inputs/http_input.rb

@@ -1,8 +1,14 @@
-require 'sinatra/base'
 require 'puma'
 require 'rack'
 require 'rack/server'
+require 'rack/protection'
+require 'uri'
+
 require 'ocular/inputs/base.rb'
+require 'ocular/dsl/runcontext.rb'
+
+# Some of this code is copied from the excellent Sinatra Ruby web library by
+# Blake Mizerany and Konstantin Haase.
 
 class Ocular
     module Inputs
@@ -11,19 +17,34 @@ class Ocular
 
             module DSL
 
-                def onGET(path, opts = {}, &block)
+
+                def onGET(path, opts = {}, &block)                    
                     handler = handlers.get(::Ocular::Inputs::HTTP::Input)
-                    handler.add_get(script_name, path, opts, &block)
+                    handler.add_get(script_name, path, opts, self, &block)
                 end
 
                 def onPOST(path, opts = {}, &block)
                     handler = handlers.get(::Ocular::Inputs::HTTP::Input)
-                    handler.add_post(script_name, path, opts, &block)
+                    handler.add_post(script_name, path, opts, self, &block)
                 end
 
+                def onDELETE(path, opts = {}, &block)
+                    handler = handlers.get(::Ocular::Inputs::HTTP::Input)
+                    handler.add_delete(script_name, path, opts, self, &block)
+                end
             end
 
             class Input < ::Ocular::Inputs::Base
+
+                attr_reader :routes
+
+                class WebRunContext < ::Ocular::DSL::RunContext
+                    attr_accessor :request, :response, :params, :env
+                end
+
+
+                URI_INSTANCE = URI::Parser.new
+
                 DEFAULT_SETTINGS = {
                     :host => '0.0.0.0',
                     :port => 8080,
@@ -31,19 +52,167 @@ class Ocular
                     :silent => false
                 }
 
-                class SinatraApp < Sinatra::Base
-                    configure do
-                        set :server, :puma
+                class Request < Rack::Request
+                    HEADER_PARAM = /\s*[\w.]+=(?:[\w.]+|"(?:[^"\\]|\\.)*")?\s*/
+                    HEADER_VALUE_WITH_PARAMS = /(?:(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*)\s*(?:;#{HEADER_PARAM})*/
+
+                    # Returns an array of acceptable media types for the response
+                    def accept
+                        @env['sinatra.accept'] ||= begin
+                        if @env.include? 'HTTP_ACCEPT' and @env['HTTP_ACCEPT'].to_s != ''
+                            @env['HTTP_ACCEPT'].to_s.scan(HEADER_VALUE_WITH_PARAMS).
+                                map! { |e| AcceptEntry.new(e) }.sort
+                            else
+                                [AcceptEntry.new('*/*')]
+                            end
+                        end
+                    end
+
+                    def accept?(type)
+                        preferred_type(type).to_s.include?(type)
+                    end
+
+                    def preferred_type(*types)
+                        accepts = accept # just evaluate once
+                        return accepts.first if types.empty?
+                        types.flatten!
+                        return types.first if accepts.empty?
+                        accepts.detect do |pattern|
+                            type = types.detect { |t| File.fnmatch(pattern, t) }
+                            return type if type
+                        end
+                    end
+
+                    alias secure? ssl?
+
+                    def forwarded?
+                        @env.include? "HTTP_X_FORWARDED_HOST"
+                    end
+
+                    def safe?
+                        get? or head? or options? or trace?
+                    end
+
+                    def idempotent?
+                        safe? or put? or delete? or link? or unlink?
+                    end
+
+                    def link?
+                        request_method == "LINK"
+                    end
+
+                    def unlink?
+                        request_method == "UNLINK"
+                    end
+
+                    private
+
+                    class AcceptEntry
+                        attr_accessor :params
+                        attr_reader :entry
+
+                        def initialize(entry)
+                            params = entry.scan(HEADER_PARAM).map! do |s|
+                                key, value = s.strip.split('=', 2)
+                                value = value[1..-2].gsub(/\\(.)/, '\1') if value.start_with?('"')
+                                [key, value]
+                            end
+
+                            @entry  = entry
+                            @type   = entry[/[^;]+/].delete(' ')
+                            @params = Hash[params]
+                            @q      = @params.delete('q') { 1.0 }.to_f
+                        end
+
+                        def <=>(other)
+                            other.priority <=> self.priority
+                        end
+
+                        def priority
+                            # We sort in descending order; better matches should be higher.
+                            [ @q, -@type.count('*'), @params.size ]
+                        end
+
+                        def to_str
+                            @type
+                        end
+
+                        def to_s(full = false)
+                            full ? entry : to_str
+                        end
+
+                        def respond_to?(*args)
+                            super or to_str.respond_to?(*args)
+                        end
+
+                        def method_missing(*args, &block)
+                            to_str.send(*args, &block)
+                        end
+                    end
+                end
+
+                class NotFound < NameError #:nodoc:
+                    def http_status; 404 end
+                end
+
+                # The response object. See Rack::Response and Rack::Response::Helpers for
+                # more info:
+                # http://rubydoc.info/github/rack/rack/master/Rack/Response
+                # http://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
+                class Response < Rack::Response
+                    DROP_BODY_RESPONSES = [204, 205, 304]
+                    def initialize(*)
+                        super
+                        headers['Content-Type'] ||= 'text/html'
+                    end
+
+                    def body=(value)
+                        value = value.body while Rack::Response === value
+                        @body = String === value ? [value.to_str] : value
                     end
 
-                    get '/noop' do
-                        puts "/check called"
-                        "OK\n"
+                    def each
+                        block_given? ? super : enum_for(:each)
+                    end
+
+                    def finish
+                        result = body
+
+                        if drop_content_info?
+                            headers.delete "Content-Length"
+                            headers.delete "Content-Type"
+                        end
+
+                        if drop_body?
+                            close
+                            result = []
+                        end
+
+                        if calculate_content_length?
+                            # if some other code has already set Content-Length, don't muck with it
+                            # currently, this would be the static file-handler
+                            headers["Content-Length"] = body.inject(0) { |l, p| l + p.bytesize }.to_s
+                        end
+
+                        [status.to_i, headers, result]
+                    end
+
+                    private
+
+                    def calculate_content_length?
+                        headers["Content-Type"] and not headers["Content-Length"] and Array === body
+                    end
+
+                    def drop_content_info?
+                        status.to_i / 100 == 1 or drop_body?
+                    end
+
+                    def drop_body?
+                        DROP_BODY_RESPONSES.include?(status.to_i)
                     end
                 end
 
                 def generate_uri_from_names(script_name, path)
-                    puts "generate_uri_from_names: #{script_name}, #{path}"
                     if path[0] == "/"
                         path = path[1..-1]
                     end
@@ -57,37 +226,286 @@ class Ocular
                     return "/" + name
                 end
 
-                def add_get(script_name, path, options = {}, &block)
+                def add_get(script_name, path, options, proxy, &block)
                     name = generate_uri_from_names(script_name, path)
-                    puts "adding get at #{name}"
-                    @app_class.get(name, options, &block)
+                    route('GET', name, options, proxy, &block)
                 end
 
-                def add_post(script_name, path, options = {}, &block)
-                    name = generate_uri_from_names(script_name, path)                    
-                    @app_class.post(name, options, &block)
+                def add_post(script_name, path, options, proxy, &block)
+                    name = generate_uri_from_names(script_name, path)
+                    route('POST', name, options, proxy, &block)
+                end
+
+                def add_delete(script_name, path, options, proxy, &block)
+                    name = generate_uri_from_names(script_name, path)
+                    route('DELETE', name, options, proxy, &block)
+                end                
+
+                def build_signature(pattern, keys, &block)
+                    return [pattern, keys, block]
+                end
+
+                def route(verb, path, options, proxy, &block)
+                    eventbase = Ocular::DSL::EventBase.new(&block)
+                    eventbase.proxy = proxy
+                    (proxy.events[verb] ||= {})[path] = eventbase
+
+                    pattern, keys = compile(path)
+
+                    (@routes[verb] ||= []) << build_signature(pattern, keys) do |context|
+                        context.event_signature = [verb, path] 
+                        eventbase.exec(context)
+                    end
+                end
+
+
+                def safe_ignore(ignore)
+                    unsafe_ignore = []
+                    ignore = ignore.gsub(/%[\da-fA-F]{2}/) do |hex|
+                        unsafe_ignore << hex[1..2]
+                        ''
+                    end
+                    unsafe_patterns = unsafe_ignore.map! do |unsafe|
+                        chars = unsafe.split(//).map! do |char|
+                            char == char.downcase ? char : char + char.downcase
+                        end
+
+                        "|(?:%[^#{chars[0]}].|%[#{chars[0]}][^#{chars[1]}])"
+                    end
+                    if unsafe_patterns.length > 0
+                        "((?:[^#{ignore}/?#%]#{unsafe_patterns.join()})+)"
+                    else
+                        "([^#{ignore}/?#]+)"
+                    end
+                end
+
+
+                def compile(path)
+                    if path.respond_to? :to_str
+                        keys = []
+
+                        # Split the path into pieces in between forward slashes.
+                        # A negative number is given as the second argument of path.split
+                        # because with this number, the method does not ignore / at the end
+                        # and appends an empty string at the end of the return value.
+                        #
+                        segments = path.split('/', -1).map! do |segment|
+                            ignore = []
+
+                            # Special character handling.
+                            #
+                            pattern = segment.to_str.gsub(/[^\?\%\\\/\:\*\w]|:(?!\w)/) do |c|
+                                ignore << escaped(c).join if c.match(/[\.@]/)
+                                patt = encoded(c)
+                                patt.gsub(/%[\da-fA-F]{2}/) do |match|
+                                    match.split(//).map! { |char| char == char.downcase ? char : "[#{char}#{char.downcase}]" }.join
+                                end
+                            end
+
+                            ignore = ignore.uniq.join
+
+                            # Key handling.
+                            #
+                            pattern.gsub(/((:\w+)|\*)/) do |match|
+                                if match == "*"
+                                    keys << 'splat'
+                                    "(.*?)"
+                                else
+                                    keys << $2[1..-1]
+                                ignore_pattern = safe_ignore(ignore)
+
+                                ignore_pattern
+                                end
+                            end
+                        end
+
+                        # Special case handling.
+                        #
+                        if last_segment = segments[-1] and last_segment.match(/\[\^\\\./)
+                            parts = last_segment.rpartition(/\[\^\\\./)
+                            parts[1] = '[^'
+                            segments[-1] = parts.join
+                        end
+                        [/\A#{segments.join('/')}\z/, keys]
+                    elsif path.respond_to?(:keys) && path.respond_to?(:match)
+                        [path, path.keys]
+                    elsif path.respond_to?(:names) && path.respond_to?(:match)
+                        [path, path.names]
+                    elsif path.respond_to? :match
+                        [path, []]
+                    else
+                        raise TypeError, path
+                    end
+                end
+
+                def call(env)
+                    dup.call!(env)
+                end
+
+                # Set or retrieve the response body. When a block is given,
+                # evaluation is deferred until the body is read with #each.
+                def body(context, value = nil, &block)
+                    if block_given?
+                        def block.each; yield(call) end
+                        context.response.body = block
+                    elsif value
+                        # Rack 2.0 returns a Rack::File::Iterator here instead of
+                        # Rack::File as it was in the previous API.
+                        unless context.request.head?
+                            headers(context).delete 'Content-Length'
+                        end
+                        context.response.body = value
+                    else
+                        context.response.body
+                    end
+                end
+
+                def call!(env)
+                    context = WebRunContext.new
+
+                    context.request = Request.new(env)
+                    context.response = Response.new
+                    context.env = env
+                    context.params = indifferent_params(context.request.params)
+
+                    context.response['Content-Type'] = nil
+                    invoke(context) { |context| dispatch(context) }
+
+                    unless context.response['Content-Type']
+                        context.response['Content-Type'] = "text/html"
+                    end
+
+                    context.response.finish
+                end
+
+                def dispatch(context)
+                    invoke(context) do |context|
+                        route!(context)
+                    end
+                rescue ::Exception => error
+                    invoke(context) do |context|
+                        handle_exception!(context, error)
+                    end
+                ensure
+                    
+                end                
+
+                def handle_exception!(context, error)
+                    context.env['error'] = error
+
+                    if error.respond_to? :http_status
+                        context.response.status = error.http_status
+                    else
+                        context.response.status = 500
+                        puts "Internal Server Error: #{error}"
+                        puts error.backtrace
+                    end
+
+                end
+
+                def call_block(context)
+                    yield(context)
+                end
+
+                def route!(context)
+                    if routes = @routes[context.request.request_method]
+                        routes.each do |pattern, keys, block|
+                            process_route(context, pattern, keys) do |*args|
+                                #env['route'] = block.instance_variable_get(:@route_name)
+
+                                #throw :halt, context.exec(&block)
+                                throw :halt, call_block(context, &block)
+                            end
+                        end
+                    end
+
+                    puts "Route missing"
+                    raise NotFound
+                end
+
+                def process_route(context, pattern, keys, values = [])
+                    route = context.request.path_info
+                    route = '/' if route.empty?
+                    return unless match = pattern.match(route)
+                    values += match.captures.map! { |v| URI_INSTANCE.unescape(v) if v }
+
+                    if values.any?
+                        original, @params = context.params, context.params.merge('splat' => [], 'captures' => values)
+                        keys.zip(values) { |k,v| Array === context.params[k] ? context.params[k] << v : context.params[k] = v if v }
+                    end
+
+                    yield(self, values)
+
+                rescue
+                    context.env['error.params'] = context.params
+                    raise
+                ensure
+                    @params = original if original
+                end                
+
+                def invoke(context)
+                    res = catch(:halt) { yield(context) }
+
+                    res = [res] if Fixnum === res or String === res
+                    if Array === res and Fixnum === res.first
+                        res = res.dup
+                        status(context, res.shift)
+                        body(context, res.pop)
+                        headers(context, *res)
+                    elsif res.respond_to? :each
+                        body(context, res)
+                    end
+                    nil # avoid double setting the same response tuple twice
+                end
+
+                # Creates a Hash with indifferent access.
+                def indifferent_hash
+                    Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+                end
+
+
+                def indifferent_params(object)
+                    case object
+                    when Hash
+                        new_hash = indifferent_hash
+                        object.each { |key, value| new_hash[key] = indifferent_params(value) }
+                        new_hash
+                    when Array
+                        object.map { |item| indifferent_params(item) }
+                    else
+                        object
+                    end
+                end
+
+                def status(context, value = nil)
+                    context.response.status = value if value
+                    context.response.status
+                end
+
+                def headers(context, hash = nil)
+                    context.response.headers.merge! hash if hash
+                    context.response.headers
                 end
 
                 def initialize(settings_factory)
                     settings = settings_factory[:http]
 
+                    @routes = {}
                     @settings = DEFAULT_SETTINGS.merge(settings)
                     @stopsignal = Queue.new()
                     @thread = nil
 
-                    @app_class = Class.new(SinatraApp)
-
                 end
 
                 def start()
-                    @app = @app_class.new
-                    if @settings[:Verbose]
+                    
+                    if @settings[:verbose]
                       @app = Rack::CommonLogger.new(@app, STDOUT)
                     end
 
                     @thread = Thread.new do
-                        events_hander = @settings[:Silent] ? ::Puma::Events.strings : ::Puma::Events.stdio
-                        server   = ::Puma::Server.new(@app, events_hander)
+                        events_hander = @settings[:silent] ? ::Puma::Events.strings : ::Puma::Events.stdio
+                        server   = ::Puma::Server.new(self, events_hander)
 
                         server.add_tcp_listener @settings[:host], @settings[:port]
                         server.min_threads = 0

data/lib/ocular/settings.rb

@@ -11,8 +11,7 @@ class Ocular
         def initialize()
         end
 
-        def self.find_settings_file_from_system()
-            filename = nil
+        def self.find_settings_file_from_system(filename)
             if ENV['OCULAR_SETTINGS'] != nil
                 filename = File.expand_path(ENV['OCULAR_SETTINGS'])
             end

data/lib/ocular/version.rb

@@ -1,3 +1,3 @@
 class Ocular
-    Version = "0.1.3"
+    Version = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocular
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Juho Mäkinen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 2016-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rye
@@ -53,19 +53,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.16.0
 - !ruby/object:Gem::Dependency
-  name: sinatra
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.4.7
+        version: 1.6.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.4.7
+        version: 1.6.4
+- !ruby/object:Gem::Dependency
+  name: rack-protection
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.3
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -120,7 +134,6 @@ files:
 - lib/ocular/dsl/ssh.rb
 - lib/ocular/event/eventbase.rb
 - lib/ocular/event/eventfactory.rb
-- lib/ocular/event/forker.rb
 - lib/ocular/inputs/base.rb
 - lib/ocular/inputs/handlers.rb
 - lib/ocular/inputs/http_input.rb

data/lib/ocular/event/forker.rb

@@ -1,35 +0,0 @@
-require 'ocular/mixin/from_file'
-require 'ocular/dsl/fog'
-require 'ocular/dsl/ssh'
-require 'ocular/dsl/logging'
-
-class Ocular
-    module Event
-
-        class Forker
-
-            def initialize(&block)
-                puts "Forker created with block #{block}"
-              @callback = block
-            end
-
-            def get_proc()
-                cb = @callback
-
-                def proxy(&block)
-                    return block
-                end
-
-                p = proxy do |*args|
-                    puts "Calling proc callback: #{cb}"
-                    cb.call(*args)
-                end
-
-                puts "returning p: #{p}"
-
-                return p
-            end
-        end
-    end
-end
-