ocean-rails 1.14.0

data/lib/ocean/ocean_resource_model.rb

@@ -0,0 +1,61 @@
+module Ocean
+  module OceanResourceModel
+    
+    extend ActiveSupport::Concern
+
+    included do
+      # Inheritable invalidation callbacks
+      after_create  { |model| model.try(:invalidate, true) }
+      after_update  { |model| model.try(:invalidate) }
+      after_touch   { |model| model.try(:invalidate) }
+      after_destroy { |model| model.try(:invalidate) }
+    end
+
+
+    module ClassMethods
+
+      #
+      # The presence of +ocean_resource_model+ in a Rails ActiveRecord model declares
+      # that the model is an Ocean resource. It takes five keyword parameters:
+      #
+      # +index+: defaults to <code>[:name]</code>. Enumerates the model attributes which
+      # may be used for parameter matching and grouping.
+      #
+      # +search+: defaults to +:description+. Names the model attribute used for substring
+      # searches. The attribute must be a string or text attribute.
+      #
+      # +page_size+: defaults to 25. When paginated collections are retrieved, this will
+      # be the default page_size for this resource.
+      #
+      # +invalidate_member+: defaults to +INVALIDATE_MEMBER_DEFAULT+. An array of strings
+      # enumerating the Varnish +BAN+ HTTP request URI suffixes to use to invalidate a
+      # resource member, including any relations derived from it.
+      #
+      # +invalidate_collection+: defaults to +INVALIDATE_COLLECTION_DEFAULT+. An array of strings
+      # enumerating the Varnish +BAN+ HTTP request URI suffixes to use to invalidate a
+      # collection of resources.
+      #
+      def ocean_resource_model(index:                 [:name], 
+      	                       search:                :description,
+                               page_size:             25,
+                               invalidate_member:     INVALIDATE_MEMBER_DEFAULT,
+                               invalidate_collection: INVALIDATE_COLLECTION_DEFAULT
+      	                      )
+      	include ApiResource
+      	cattr_accessor :index_only
+      	cattr_accessor :index_search_property
+        cattr_accessor :collection_page_size
+        cattr_accessor :varnish_invalidate_member
+        cattr_accessor :varnish_invalidate_collection
+      	self.index_only = index
+      	self.index_search_property = search
+        self.collection_page_size = page_size
+        self.varnish_invalidate_member = invalidate_member
+        self.varnish_invalidate_collection = invalidate_collection
+      end
+    end
+  end
+end
+
+
+ActiveRecord::Base.send :include, Ocean::OceanResourceModel

data/lib/ocean/selective_rack_logger.rb

@@ -0,0 +1,33 @@
+#
+# This custom Rack middleware is used to turn off logging of requests made to
+# <code>/alive</code> by Varnish every 15 seconds in order to detect 
+# failing instances for failover purposes.
+#
+class SelectiveRackLogger < Rails::Rack::Logger
+
+  #
+  # Initialises the selective Rack logger.
+  #
+  def initialize(app, opts = {})
+    @app = app
+    super
+  end
+
+  #
+  # Suppresses logging of /alive requests from Varnish.
+  #
+  def call(env)
+    if env['PATH_INFO'] == "/alive"
+      old_level = Rails.logger.level
+      Rails.logger.level = 1234567890              # > 5
+      begin
+        @app.call(env)                             # returns [..., ..., ...]
+      ensure
+        Rails.logger.level = old_level
+      end
+    else
+      super(env)                                   # returns [..., ..., ...]
+    end
+  end
+
+end

data/lib/ocean/version.rb

@@ -0,0 +1,3 @@
+module Ocean
+  VERSION = "1.14.0"
+end

data/lib/ocean/zero_log.rb

@@ -0,0 +1,184 @@
+require 'ffi-rzmq'
+
+
+#
+# This is the class that provides the interface to ZeroMQ, both for sending log
+# data to a cluster of log servers, and for receiving it.
+#
+# The Rails logger is replaced in production by the initializer zero_mq_logger.rb.
+#
+# The worker daemons running on the log machines use the pull_server and 
+# pull_worker methods in this class.
+#
+class ZeroLog
+
+  #
+  # This is the ZeroMQ context. We only need one per process, thus we
+  # store it in a class variable.
+  #
+  @@context = nil
+
+
+  #
+  # When the first ZeroLog instance is created, a ZeroMQ Context will be
+  # set up for the use of all threads in the process. A process exit 
+  # handler will be set up to terminate the context on exit.
+  #
+  def initialize
+    super
+    unless @@context
+      #puts "Creating context"
+      @@context = ZMQ::Context.new(1)
+      #puts "Registering at_exit context terminator"
+      at_exit { @@context.terminate
+                #puts "Context terminated" 
+              }
+    end
+  end
+
+
+  #
+  # This method returns the ZeroMQ Context object.
+  #
+  def context
+  	@@context
+  end
+
+
+  #
+  # Register a trap handler for INT, to clean up and close any
+  # sockets we might have opened previously.
+  #
+  def trap_int(*sockets)
+    sockets.each do |s|
+      #puts "Registering at_exit socket closer"
+      at_exit { s.setsockopt(ZMQ::LINGER, 0)
+                s.close
+                #puts "Socket closed" 
+              }
+    end
+  end
+
+
+  # ---------------------------------------------------------------------------
+  #
+  # Log data sender side (ruby, Ruby on Rails)
+  #
+  # ---------------------------------------------------------------------------
+
+  #
+  # This initialises the log data sender. We begin by creating the server and
+  # binding it; this is required when using +inproc+ sockets: bind must precede
+  # any connects. (Normally in ZeroMQ, this is not the case.) The code sets up,
+  # in a new thread, a +SUB+ server which is then connected to a +PUSH+ socket. The
+  # +SUB+ server waits for log data which is then pushed via the +PUSH+ socket to
+  # all available +LOG_HOSTS+. ZeroMQ handles buffering, re-connection and multiplexing
+  # (round-robin) to the +LOG_HOSTS+ +PULL+ servers.
+  #
+  def init_log_data_sender(sub_push="sub_push")
+    # First create the server and let it bind, as this is required
+    # when using inproc: bind must precede any connects.
+    Thread.new(context) do |c|
+      # Set up the server socket
+      #puts "Starting SUB server"
+      subscriber = c.socket(ZMQ::SUB)
+      #puts "Binding to the SUB socket"
+      subscriber.bind("inproc://#{sub_push}")
+      subscriber.setsockopt(ZMQ::SUBSCRIBE, "")
+      # Set up the PUSH socket
+      loggers = context.socket(ZMQ::PUSH)
+      LOG_HOSTS.each do |host|
+        #puts "Connecting to the PULL server #{host}"
+        loggers.connect("tcp://#{host}:10000")
+      end
+      # Connect SUB to PUSH via a queue and block
+      ZMQ::Device.new(ZMQ::QUEUE, subscriber, loggers)
+      # Context has been terminated, close sockets
+      subscriber.setsockopt(ZMQ::LINGER, 0)
+      subscriber.close
+      loggers.setsockopt(ZMQ::LINGER, 0)
+      loggers.close
+      #puts "Closed sockets in other thread"
+    end
+
+    sleep 0.1  # Brute force and primitive, but it works
+
+    # Next create the PUB socket and connect it to the other thread
+    #puts "Creating the PUB socket"
+    $log_publisher = context.socket(ZMQ::PUB) 
+    trap_int($log_publisher)
+    #puts "Connecting to the SUB server"
+    $log_publisher.connect("inproc://#{sub_push}")
+  end
+
+
+  #
+  # This is a combination of a PUB main thread log data sender,
+  # pushing directly to the pull_server without the need for a local
+  # aggregator.
+  #
+  def log(data)
+    init_log_data_sender unless $log_publisher
+
+    # Send the data
+    json = data.to_json
+    #puts "Sending message #{json}"
+    $log_publisher.send_string(json)
+    data
+  end
+
+
+  # ---------------------------------------------------------------------------
+  #
+  # Log service (aggregation) side
+  #
+  # ---------------------------------------------------------------------------
+
+  #
+  # This is the inter-process ZeroMQ socket to which the Log workers send
+  # their received data.
+  #
+  PUSH_ADDRESS = "ipc://pull_worker.ipc"
+
+
+  #
+  # This is the PULL to PUSH server. It pushes the received data over IPC 
+  # round-robin fashion to each PULL log worker on the machine.
+  #
+  def pull_server(address=PUSH_ADDRESS)
+  	#puts "Starting PULL server"
+  	puller = context.socket(ZMQ::PULL)
+  	#puts "Binding to the PULL socket"
+  	puller.bind("tcp://*:10000")
+    # Set up the PUSH socket
+    pusher = context.socket(ZMQ::PUSH)
+    #puts "Binding to the PUSH socket"
+    pusher.bind(address)
+    # Trap everything
+    trap_int(puller, pusher)
+    # Connect PULL to PUSH via a queue
+    ZMQ::Device.new(ZMQ::QUEUE, puller, pusher)
+  end
+
+
+  #
+  # This is the PULL worker. This particular version just prints all 
+  # received data to STDOUT. Overload this method for other types of
+  # processing (such as storing received log info in a database).
+  #
+  def pull_worker(address=PUSH_ADDRESS)
+  	#puts "Starting PULL worker"
+  	puller = context.socket(ZMQ::PULL)
+  	#puts "Connect to the PUSH socket"
+    puller.connect(address)
+    trap_int(puller)
+
+  	while true do
+  	  s = ''
+  	  puller.recv_string(s)
+  	  puts "Received: #{s}"
+  	end
+  end
+
+
+end

data/lib/ocean/zeromq_logger.rb

@@ -0,0 +1,42 @@
+require 'socket'
+
+class ZeromqLogger
+
+  attr_accessor :level, :log_tags
+
+
+  def initialize
+    super
+    # Get info about our environment
+    @ip = Socket.ip_address_list.detect{|intf| intf.ipv4_private?}.getnameinfo[0] 
+    # Set up the logger
+    @logger = ZeroLog.new
+    @logger.init_log_data_sender "/tmp/sub_push_#{Process.pid}"
+  end
+
+
+  def debug?() @level <= 0; end
+  def info?()  @level <= 1; end
+  def warn?()  @level <= 2; end
+  def error?() @level <= 3; end
+  def fatal?() @level <= 4; end
+
+
+  def add(level, msg, progname)
+    return true if level < @level
+    msg = progname if msg.blank?
+    return true if msg.blank?       # Don't send
+    #puts "Adding #{level} #{msg} #{progname}"
+    milliseconds = (Time.now.utc.to_f * 1000).to_i
+    data = { timestamp: milliseconds,
+             ip:        @ip,
+             pid:       Process.pid,
+             service:   APP_NAME,
+             level:     level,
+             msg:       msg.kind_of?(String) ? msg : msg.inspect
+           }
+    @logger.log data
+    true
+  end
+
+end

data/lib/tasks/ocean_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :ocean do
+#   # Task goes here
+# end

data/lib/template.rb

@@ -0,0 +1,31 @@
+# Update the Gemfile
+gem "ocean-rails", git: "git://github.com/OceanDev/ocean-rails.git"
+
+# Install a .rvmrc file
+run "rvm rvmrc create ruby-2.0.0-p195@rails-4.0.0"
+# Select the ruby and gem bag
+run "rvm use ruby-2.0.0-p195@rails-4.0.0"
+# Run bundle install - we need the generators in it now
+run "bundle install"
+
+# Set up the application as a SOA service Rails application
+generate "ocean_setup", app_name
+
+# Install the required gems and package them with the app
+run "bundle install"
+run "bundle package --all"
+
+# Remove the asset stuff from the application conf file
+gsub_file "config/application.rb", 
+          /    # Enable the asset pipeline.+config\.assets\.version = '1\.0'\s/m, ''
+
+# Set up SQLite to run tests in memory
+gsub_file "config/database.yml",
+          /test:\s+adapter: sqlite3\s+database: db\/test.sqlite3/m,
+          'test:
+  adapter: sqlite3
+  database: ":memory:"
+  verbosity: quiet'
+
+# Get the DBs in order
+rake "db:migrate"

data/lib/templates/rails/scaffold_controller/controller.rb

@@ -0,0 +1,91 @@
+<% if namespaced? -%>
+require_dependency "<%= namespaced_file_path %>/application_controller"
+
+<% end -%>
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+
+  ocean_resource_controller required_attributes: [:lock_version, :name, :description]
+
+  respond_to :json
+  
+  before_action :find_<%= singular_table_name %>, :only => [:show, :update, :destroy]
+    
+  
+  # GET <%= route_url %>
+  def index
+    expires_in 0, 's-maxage' => 30.minutes
+    if stale?(collection_etag(<%= class_name %>))
+      api_render <%= class_name %>.collection(params)
+    end
+  end
+
+
+  # GET <%= route_url %>/1
+  def show
+    expires_in 0, 's-maxage' => 30.minutes
+    if stale?(@<%= singular_table_name %>)
+      api_render @<%= singular_table_name %>
+    end
+  end
+
+
+  # POST <%= route_url %>
+  def create
+    @<%= singular_table_name %> = <%= class_name %>.new(filtered_params <%= class_name %>)
+    set_updater(@<%= singular_table_name %>)
+    if @<%= singular_table_name %>.valid?
+      begin
+        @<%= singular_table_name %>.save!
+      rescue ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid, 
+             SQLite3::ConstraintException 
+        render_api_error 422, "<%= class_name %> already exists"
+        return
+      end
+      api_render @<%= singular_table_name %>, new: true
+    else
+      render_validation_errors @<%= singular_table_name %>
+    end
+  end
+
+
+  # PUT <%= route_url %>/1
+  def update
+    if missing_attributes?
+      render_api_error 422, "Missing resource attributes"
+      return
+    end
+    begin
+      @<%= singular_table_name %>.assign_attributes(filtered_params <%= class_name %>)
+      set_updater(@<%= singular_table_name %>)
+      @<%= singular_table_name %>.save
+    rescue ActiveRecord::StaleObjectError
+      render_api_error 409, "Stale <%= class_name %>"
+      return
+    end
+    if @<%= singular_table_name %>.valid?
+      api_render @<%= singular_table_name %>
+    else
+      render_validation_errors(@<%= singular_table_name %>)
+    end
+  end
+
+
+  # DELETE <%= route_url %>/1
+  def destroy
+    @<%= orm_instance.destroy %>
+    render_head_204
+  end
+  
+  
+  private
+     
+  def find_<%= singular_table_name %>
+    @<%= singular_table_name %> = <%= class_name %>.find_by_id params[:id]
+    return true if @<%= singular_table_name %>
+    render_api_error 404, "<%= class_name %> not found"
+    false
+  end
+    
+end
+<% end -%>