cloudpi-appmetric 0.1.0 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/cloudpi-appmetric.rb

@@ -1,177 +1,158 @@
 require 'socket'
 require 'json'
+require 'thread'
 
 module CloudPI
 
 class AppMetric
-
-  class CircularQueue
-
-    def initialize(size)
-      @memory = []
-      @front = 0
-      @rear = 0
-      @lock = Mutex.new
-
-      @queue_size = size
-    end
-
-    def is_empty
-      @lock.synchronize { return @front == @rear }
-    end
-
-    def is_full
-      @lock.synchronize { return ((@rear + 1) % @queue_size) == @front }
-    end
-
-    def first
-      return nil if is_empty
-      @lock.synchronize { return @memory[(@front + 1) % @queue_size] }
-    end
-
-    def pop
-      return if is_empty
-      @lock.synchronize { @front = (@front + 1) % @queue_size }
-    end
-
-    def enqueue(data)
-      if is_full
-        @lock.synchronize {
-          @front = (@front + 1) % @queue_size
-          @rear = (@rear + 1) % @queue_size
-          @memory[@rear] = data
-        }
-      else
-        @lock.synchronize {
-          @rear = (@rear + 1) % @queue_size
-          @memory[@rear] = data
-        }
-      end
-    end
-
-    def dequeue
-      return nil if is_empty
-
-      @lock.synchronize {
-        @front = (@front + 1) % @queue_size
-        return @memory[@front]
-      }
-    end
-
-    def cursor
-      return "#{@front}:#{@rear}"
+  
+  # sleep time in thread loop - checking queue, retrying to connect.
+  SLEEP_TIME = 3.0  # sec
+  
+  def initialize(bridge_ip = 'localhost', bridge_port = 5999, policy = '{}')
+    @bridge_ip     = bridge_ip
+    @bridge_port   = bridge_port
+    @queue         = SizedQueue.new(4096)
+    @mutex         = Mutex.new
+    
+    begin
+      json         = JSON.parse(ENV['VCAP_APPLICATION'], {:symbolize_names => true})
+      @app_ip      = json[:host]
+      @app_port    = json[:port]
+      @app_id      = json[:app_id]
+      @instance_id = json[:instance_id]
+    rescue JSON::ParserError, TypeError
+      # parsing error: ENV['VCAP_APPLICATION']
+      # log error "parsing error: ENV['VCAP_APPLICATION']"
     end
-  end
-
-  def initialize(bridge_ip = 'localhost', bridge_port = 5999, metric_policy = '{}')
-    @app_ip = ENV["VCAP_APP_HOST"] || '127.0.0.1'
-    @app_port = ENV["VCAP_APP_PORT"] || 9999
-    env_vcap_application = JSON.parse(ENV["VCAP_APPLICATION"])
-    app_id = env_vcap_application["app_id"] if env_vcap_application
-    instance_id = env_vcap_application["instance_id"] if env_vcap_application
-    @app_id = app_id || ''
-    @instance_id = instance_id || ''
-    @bridge_ip = bridge_ip
-    @bridge_port = bridge_port
-    @metric_policy = JSON.parse(metric_policy)
-    @queue = CircularQueue.new(4096)
     
+    @policy           = parse(metric_policy)
+    @policy_published = false
+    
+    # log info "key: @#!$!"
     connect
-    thread_loop
+    run
   end
-
+  
   def connect
     begin
       @conn = TCPSocket.new(@bridge_ip, @bridge_port)
-      make_policy_unpublished
-      send_metric_policy
+      # log info "connected to bridge"
+      @policy_published = false
+      send_policy
     rescue
       # ignore connection error
+      # log error "cann't connect to bridge."
       nil
     end
   end
-
+  
   def close
     @conn.close if @conn
+    # log info "connection closed"
   end
-
-  def metric_key
-    # "IP-ADDRESS:PORT:APP-ID:INSTANCE-ID" or
-    # "IP-ADDRESS:PORT:APP-INSTANCE-ID".
-
-    # "#{@app_ip}:#{@app_port}:#{@instance_id}"
-    "#{@app_ip}:#{@app_port}:#{@app_id}:#{@instance_id}"
+  
+  def key
+    :"#{@app_ip}:#{@app_port}:#{@app_id}:#{@instance_id}"
   end
-
-  def set_metric_policy(metric_policy)
-    # TODO: parse error handling
-    @metric_policy = JSON.parse(metric_policy)
+  
+  def parse(raw)
+    begin
+      json = JSON.parse(raw, {:symbolize_names => true})
+      json = {} unless json.is_a?(Hash)
+      json
+    rescue JSON::ParserError
+      # log error "parse error"
+      {}
+    end
   end
-
-  def make_policy_unpublished
-    @is_policy_published = false;
+  
+  def circular_enqueue(obj)
+    # enqueue like a circular-queue
+    # store messages into queue then loop thread will push to bridge
+    @mutex.synchronize {
+      begin
+        while @queue.length >= @queue.max do
+          # queue is full.
+          # log info "queue is full."
+          @queue.pop(true)
+        end
+      rescue ThreadError
+        # queue is empty.
+        # log info "queue is empty."
+      end
+      @queue.push(obj)
+    }
   end
-
-  def send_metric_policy
-    send_metric_value(@metric_policy.to_json)
-    @is_policy_published = true;
+  
+  def set_policy(policy)
+    @policy = parse(policy)
+    # log info "set_policy: #{@policy.to_json}"
   end
-
+  
+  def add_policy(policy)
+    # TODO
+  end
+  
+  def remove_policy(policy)
+    # TODO
+  end
+  
   def send_heartbeat
-    send_metric_value({:alive => Time.now.to_i}.to_json)
+    # log debug "heartbeat into queue"
+    circular_enqueue({:"#{key}" => {:alive => Time.now.to_i}}.to_json)
   end
-
-  def send_metric_value(message)
-    # TODO: parse error handling
-    # add 'when' value into message -> {:when => Time.now, ... }
-    msg = JSON.parse(message)
+  
+  def send_policy
+    # log debug "policy into queue"
+    @policy[:when] = Time.now.to_i
+    circular_enqueue({:"#{key}" => @policy}.to_json)
+    @policy_published = true;
+  end
+  
+  def send_metric(metric)
+    # log debug "metric into queue"
+    msg = parse(metric)
     msg[:when] = Time.now.to_i
-    # add metric_key -> {"metric_key":"message"}
-    message = {metric_key => msg}.to_json
-
-    @queue.enqueue(message)
+    circular_enqueue({:"#{key}" => msg}.to_json)
   end
+  
+  def set_trap(thread)
+    # Thread exit when signal triggered
+    Signal.trap("TERM") do
+      # log info "TERM signal received."
+      Thread.kill(thread) if thread
+    end
+  end
+  
+  def run
+    # no needs to send heartbeat, dea will do that..
 
-  def thread_loop
-    thread = Thread.new do
+    t = Thread.new do
       loop do
-        while !@queue.is_empty do
-          # puts "not empty queue: #{@queue.cursor}"
-          @message = @queue.first
+
+        # log debug "queue capacity: #{@queue.length}/#{@queue.max}"
+        while !@queue.empty? do
+          @msg = @queue.pop unless @msg  # @msg stores last failed msg.
           begin
-            @conn.write("#{@message}\0")
-            # puts "send msg: #{@message}"
-            @queue.pop
+            @conn.write("#{@msg}\0")
+            # log debug "send msg: #{@msg}"
+            @msg = nil
           rescue
             # retry to connect
-            sleep(1.0)
+            # log error "cann't write to bridge."
+            sleep(SLEEP_TIME)
             connect
           end
         end # while
-        sleep(3.0)
-      end # loop
-    end # thread
-    
-    # no need to send heartbeat, dea metric will do that..
-    
-    # heartbeat_thread = Thread.new do
-    #   loop do
-    #     send_heartbeat
-    #     sleep(10.0)
-    #   end # loop
-    # end # thread
-    
-    set_trap(thread)
-    # set_trap(heartbeat_thread)
-  end
 
-  def set_trap(thread)
-    # Thread exit when signal triggered
-    Signal.trap("TERM") do
-      Thread.kill(thread) if thread
+        sleep(SLEEP_TIME) # queue is empty
+      end
     end
+    
+    set_trap(t)
   end
-
+  
 end
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cloudpi-appmetric
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Junsang Yang
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-10 00:00:00 Z
+date: 2012-06-11 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   type: :development