da_funk 0.4.4

data/lib/iso8583/version.rb

@@ -0,0 +1,6 @@
+# -*- mode: ruby; encoding: utf-8; tab-width: 2; indent-tabs-mode: nil -*-
+
+module ISO8583
+  VERSION = "0.1.5.a"
+end
+

data/lib/serfx/commands.rb

@@ -0,0 +1,191 @@
+module Serfx
+  # Implements all of Serf's rpc commands using
+  # Serfx::Connection#request method
+  module Commands
+    # performs initial hanshake of an RPC session. Handshake has to be the
+    # first command to be invoked during an RPC session.
+    #
+    # @return  [Response]
+    def handshake
+      tcp_send(:handshake, 'Version' => 1)
+      read_response(:handshake)
+    end
+
+    # authenticate against the serf agent. if RPC credentials are setup, then
+    # `auth` has to be second command, immediately after `handshake`.
+    #
+    # @return  [Response]
+    def auth
+      tcp_send(:auth, 'AuthKey' => @authkey)
+      read_response(:auth)
+    end
+    # fires an user event
+    #
+    # @param name [String] a string representing name of the event
+    # @param payload [String] payload, default is nil
+    # @param coalesce [Boolena] whether serf should coalesce events within
+    # same name during  similar time frame
+    # @return  [Response]
+    def event(name, payload = nil, coalesce = true)
+      event = {
+        'Name' => name,
+        'Coalesce' => coalesce
+      }
+      event['Payload'] = payload unless payload.nil?
+      request(:event, event)
+    end
+
+    # force a failed node to leave the cluster
+    #
+    # @param node [String] name of the failed node
+    # @return  [Response]
+    def force_leave(node)
+      request(:force_leave, 'Node' => node)
+    end
+
+    # join an existing cluster.
+    #
+    # @param existing [Array] an array of existing serf agents
+    # @param replay [Boolean] Whether events should be replayed upon joining
+    # @return  [Response]
+    def join(existing, replay = false)
+      request(:join, 'Existing' => existing, 'Replay' => replay)
+    end
+
+    # obtain the list of existing members
+    #
+    # @return  [Response]
+    def members
+      request(:members)
+    end
+
+    # obatin the list of cluster members, filtered by tags.
+    #
+    # @param tags [Array] an array of tags for filter
+    # @param status [Boolean] filter members based on their satatus
+    # @param name [String] filter based on exact name or pattern.
+    #
+    # @return  [Response]
+    def members_filtered(tags, status = 'alive', name = nil)
+      filter = {
+        'Tags' => tags,
+        'Status' => status
+      }
+      filter['Name'] = name unless name.nil?
+      request(:members_filtered, filter)
+    end
+
+    # alter the tags on a Serf agent while it is running. A member-update
+    # event will be triggered immediately to notify the other agents in the
+    # cluster of the change. The tags command can add new tags, modify
+    # existing tags, or delete tags
+    #
+    # @param tags [Hash] a hash representing tags as key-value pairs
+    # @param delete_tags [Array] an array of tags to be deleted
+    # @return  [Response]
+    def tags(tags, delete_tags = [])
+      request(:tags, 'Tags' => tags, 'DeleteTags' => delete_tags)
+    end
+
+    # subscribe to a stream of all events matching a given type filter.
+    # Events will continue to be sent until the stream is stopped
+    #
+    # @param types [String] comma separated list of events
+    # @return  [Thread, Response]
+    def stream(types, &block)
+      res = request(:stream, {'Type' => types})
+      loop do
+        header, ev = read_data(self.stream_timeout)
+        check_rpc_error!(header)
+        break unless fiber_yield!(ev)
+      end
+      res
+    end
+
+    # monitor is similar to the stream command, but instead of events it
+    # subscribes the channel to log messages from the agent
+    #
+    # @param loglevel [String]
+    # @return  [Response]
+    def monitor(loglevel = 'debug')
+      request(:monitor, 'LogLevel' => loglevel.upcase)
+    end
+
+    # stop is used to stop either a stream or monitor
+    def stop(sequence_number)
+      tcp_send(:stop, 'Stop' => sequence_number)
+    end
+
+    # leave is used trigger a graceful leave and shutdown of the current agent
+    #
+    # @return  [Response]
+    def leave
+      request(:leave)
+    end
+
+    # query is used to issue a new query
+    #
+    # @param name [String] name of the query
+    # @param payload [String] payload for this query event
+    # @param opts [Hash] additional query options
+    # @return  [Response]
+    def query(name, payload, opts = {}, &block)
+      params = { 'Name' => name, 'Payload' => payload }
+      params.merge!(opts)
+      res = request(:query, params)
+      loop do
+        header, ev = read_data
+        check_rpc_error!(header)
+        break unless fiber_yield!(ev)
+      end
+      res
+    end
+
+    # respond is used with `stream` to subscribe to queries and then respond.
+    #
+    # @param id [Integer] an opaque value that is assigned by the IPC layer
+    # @param payload [String] payload for the response event
+    # @return  [Response]
+    def respond(id, payload)
+      request(:respond, 'ID' => id, 'Payload' => payload)
+    end
+
+    # install a new encryption key onto the cluster's keyring
+    #
+    # @param key [String] 16 bytes of base64-encoded data.
+    # @return  [Response]
+    def install_key(key)
+      request(:install_key, 'Key' => key)
+    end
+
+    # change the primary key, which is used to encrypt messages
+    #
+    # @param key [String] 16 bytes of base64-encoded data.
+    # @return  [Response]
+    def use_key(key)
+      request(:use_key, 'Key' => key)
+    end
+
+    # remove a key from the cluster's keyring
+    #
+    # @param key [String] 16 bytes of base64-encoded data.
+    # @return  [Response]
+    def remove_key(key)
+      request(:remove_key, 'Key' => key)
+    end
+
+    # return a list of all encryption keys currently in use on the cluster
+    #
+    # @return  [Response]
+    def list_keys
+      request(:list_keys)
+    end
+
+    # obtain stats about the agent(same as info command)
+    #
+    # @return  [Response]
+    def stats
+      request(:stats)
+    end
+  end
+end

data/lib/serfx/connection.rb

@@ -0,0 +1,160 @@
+module Serfx
+  # This class wraps the low level msgpack data transformation and tcp
+  # communication for the RPC session. methods in this module are used to
+  # implement the actual RPC commands available via [Commands]
+  class Connection
+    MAX_MESSAGE_SIZE = 1024
+    DEFAULT_TIMEOUT  = 15
+    COMMANDS = {
+      handshake:        [:header],
+      auth:             [:header],
+      event:            [:header],
+      force_leave:      [:header],
+      join:             [:header, :body],
+      members:          [:header, :body],
+      members_filtered: [:header, :body],
+      tags:             [:header],
+      stream:           [:header],
+      monitor:          [:header],
+      stop:             [:header],
+      leave:            [:header],
+      query:            [:header],
+      respond:          [:header],
+      install_key:      [:header, :body],
+      use_key:          [:header, :body],
+      remove_key:       [:header, :body],
+      list_keys:        [:header, :body],
+      stats:            [:header, :body]
+    }
+
+    include Serfx::Commands
+
+    attr_reader :host, :port, :seq, :socket, :socket_tcp, :socket_block, :timeout, :stream_timeout
+
+    def close
+      @socket_tcp.close
+      @socket.close
+    end
+
+    def closed?
+      @socket_tcp.closed?
+    end
+
+    # @param  opts [Hash] Specify the RPC connection details
+    # @option opts [TCPSocket] :socket_tcp Socket
+    # @option opts [SSL] :socket Socket SSL or normal tcp socket
+    # @option opts [Fixnum] :timeout Timeout in seconds to wait for a event and return Fiber
+    # @option opts [Symbol] :authkey encryption key for RPC communication
+    # @option opts [Block] :socket_block Callback to create socket if socket was closed, should return [socket, socket_tcp]
+    def initialize(opts = {})
+      if @socket_block = opts[:socket_block]
+        @socket, @socket_tcp = @socket_block.call
+      else
+        @socket = opts[:socket]
+        @socket_tcp = opts[:socket_tcp]
+      end
+      @timeout = opts[:timeout] || DEFAULT_TIMEOUT
+      @stream_timeout = opts[:stream_timeout] || DEFAULT_TIMEOUT
+      @seq = 0
+      @authkey = opts[:authkey]
+      @requests = {}
+      @responses = {}
+    end
+
+    # read data from tcp socket and pipe it through msgpack unpacker for
+    # deserialization
+    #
+    # @return [Hash]
+    def read_data(read_timeout = self.timeout)
+      buf = read_buffer(read_timeout)
+      return if buf.nil?
+
+      # TODO Check first and second(header and body) packet size
+      first_packet, second_packet = buf.split("\x85")
+      if second_packet.nil?
+        [MessagePack.unpack(first_packet), nil]
+      else
+        [MessagePack.unpack(first_packet), MessagePack.unpack("\x85" + second_packet)]
+      end
+    end
+
+    def read_buffer(read_timeout)
+      time_timeout = Time.now + read_timeout
+      loop do
+        bytes = socket.bytes_available
+        return socket.read(bytes) if bytes > 0
+        break unless time_timeout > Time.now
+        sleep 1
+      end
+      nil
+    end
+
+    # takes raw RPC command name and an optional request body
+    # and convert them to msgpack encoded data and then send
+    # over tcp
+    #
+    # @param command [String] RPC command name
+    # @param body [Hash] request body of the RPC command
+    #
+    # @return [Integer]
+    def tcp_send(command, body = nil)
+      @seq += 1
+      header = {
+        'Command' => command.to_s.gsub('_', '-'),
+        'Seq' => seq
+      }
+      buff = MessagePack::Packer.new
+      buff.write(header)
+      buff.write(body) unless body.nil?
+      res = socket.write(buff.to_str)
+      @requests[seq] = { header: header, ack?: false }
+      seq
+    end
+
+    # checks if the RPC response header has `error` field popular or not
+    # raises [RPCError] exception if error string is not empty
+    #
+    # @param header [Hash] RPC response header as hash
+    def check_rpc_error!(header)
+      if header
+        raise RPCError, header['Error'] unless header['Error'].empty?
+      end
+    end
+
+    # read data from the tcp socket. and convert it to a [Response] object
+    #
+    # @param command [String] RPC command name for which response will be read
+    # @return [Response]
+    def read_response(command, read_timeout = self.timeout)
+      header, body = read_data(read_timeout)
+      check_rpc_error!(header)
+      if COMMANDS[command].include?(:body)
+        Response.new(header, body)
+      else
+        Response.new(header)
+      end
+    end
+
+    # make an RPC request against the serf agent
+    #
+    # @param command [String] name of the RPC command
+    # @param body [Hash] an optional request body for the RPC command
+    # @return [Response]
+    def request(command, body = nil, read_timeout = self.timeout)
+      tcp_send(command, body)
+      read_response(command, read_timeout)
+    end
+
+    def fiber_yield!(ev)
+      if Fiber.yield(ev) == "close"
+        self.close
+        false
+      elsif self.closed?
+        false
+      else
+        true
+      end
+    end
+  end
+end
+

data/lib/serfx/exceptions.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module Serfx
+  class RPCError < RuntimeError; end
+end

data/lib/serfx/response.rb

@@ -0,0 +1,28 @@
+module Serfx
+  # Store agent rpc response data
+  # All RPC responses in Serf composed of an header and an optional
+  # body.
+  #
+  class Response
+    # Header is composed of two sub-parts
+    # - Seq : an integer representing the original request
+    # - Error: a string that represent whether the request made, was
+    #   successfull or no. For all successful RPC requests, Error should
+    #   be an empty string
+    #
+    # `{"Seq": 0, "Error": ""}`
+    #
+    Header = Struct.new(:seq, :error)
+    attr_reader :header, :body
+
+    # Constructs a response object from a given header and body.
+    #
+    # @param header [Hash] header of the response as hash
+    # @param body [Hash] body of the response as hash
+    def initialize(header, body = nil)
+      @header = Header.new(header['Seq'], header['Error']) if header
+      @body = body
+    end
+  end
+end
+

data/lib/serfx.rb

@@ -0,0 +1,27 @@
+
+module Serfx
+  # Creates a serf rpc connection, performs handshake and auth
+  # (if authkey is supplied). If a block is provided, the connection
+  # object will be yield-ed and the connection will be closed after
+  # the block's execution, otherwise the connection will be returned
+  # Params:
+  # +opts+:: An optional hash which can have following keys:
+  # * host => Serf host's rpc bind address (127.0.0.1 by default)
+  # * port => Serf host's rpc port (7373 by default)
+  # * authkey => Encryption key for RPC communiction
+  #
+  # @return value of the block evaluation or the connection object
+  def self.connect(opts = {})
+    conn = Serfx::Connection.new(opts)
+    conn.handshake
+    conn.auth if opts.key?(:authkey)
+    res = nil
+    if block_given?
+      res = yield conn
+      conn.close unless conn.closed?
+      res
+    else
+      conn
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+
+class Device
+  API_VERSION="0.4.4"
+end
+

data/lib/zip.rb

@@ -0,0 +1,29 @@
+module Zip
+  def self.compress(*args)
+    Miniz.zip(*args)
+  end
+
+  def self.uncompress(filezip, path = ".")
+    dir = "#{path}/#{filezip.split(".")[0]}"
+    clean(dir)
+    Miniz.unzip(filezip, path)
+  end
+
+  def self.clean(dir)
+    # TODO Refactor file check
+    if Dir.exist?(dir)
+      files = Dir.entries(dir)
+      if (files.size > 2)
+        files[2..-1].each do |file|
+          if File.file?("#{dir}/#{file}")
+            File.delete("#{dir}/#{file}")
+          else
+            Dir.delete("#{dir}/#{file}")
+          end
+        end
+      end
+      Dir.delete(dir)
+    end
+    Dir.mkdir(dir)
+  end
+end

data/test/integration/getc_test.rb

@@ -0,0 +1,6 @@
+
+class GetcTest < DaFunk::Test.case
+  def test_getc
+    assert_equal "a", getc(1000)
+  end
+end

data/test/integration/mrb_eval_test.rb

@@ -0,0 +1,36 @@
+
+class MrbEvalTest < DaFunk::Test.case
+  def test_socket
+    Device::Setting.environment = "staging"
+    Device::Setting.host = Device::Setting::HOST_STAGING
+    Device::Setting.company_name = "pc1"
+    Device::Setting.logical_number = "1234"
+
+    Device::Notification.start
+    Device::Notification.check
+
+    http = SimpleHttp.new('http', 'http://google.com', 443)
+    http.socket = Device::Network.walk_socket
+    assert_equal 302, http.get('/').code
+
+    command =<<EOF
+    require 'da_funk'
+    require 'da_funk/simplehttp'
+    require '../utils/command_line_platform.rb'
+    Device::Setting.environment = "staging"
+    Device::Setting.host = Device::Setting::HOST_STAGING
+    Device::Setting.company_name = "pc1"
+    Device::Setting.logical_number = "1234"
+
+    Device::Network.socket = nil
+    http = SimpleHttp.new('http', 'http://google.com', 80)
+    http.socket = Device::Network.walk_socket
+    response = http.get('/')
+    Device::Network.socket = nil
+    response.code
+EOF
+    command << " \n; mrb_eval(#{command.inspect})"
+
+    assert_equal 302, mrb_eval(command)
+  end
+end

data/test/integration/notification_test.rb

@@ -0,0 +1,20 @@
+
+class NotificationTest < DaFunk::Test.case
+  def test_notification
+    Device::Setting.company_name = "pc1"
+    Device::Setting.logical_number = "0101"
+    notification = Device::Notification.new
+    assert_equal nil, notification.check
+    notification.check
+    notification.check
+    assert notification.close
+    assert notification.closed?
+    notification = Device::Notification.new
+    assert_equal nil, notification.check
+    notification.check
+    notification.check
+    notification.close
+    assert notification.closed?
+  end
+end
+

data/test/integration/params_dat_test.rb

@@ -0,0 +1,11 @@
+
+class ParamsDatTest < DaFunk::Test.case
+  def test_parse_apps
+    Device::Setting.environment = "staging"
+    Device::Setting.host = Device::Setting::HOST_STAGING
+    Device::Setting.company_name = "pc1"
+    Device::Setting.logical_number = "1410"
+    Device::ParamsDat.update_apps
+    Device::ParamsDat.application_menu
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+
+if Object.const_defined?(:MTest)
+  ROOT_PATH = File.expand_path("./")
+  APP_NAME = File.basename(File.dirname(ROOT_PATH))
+
+  $LOAD_PATH.unshift "./#{APP_NAME}"
+
+  require 'da_funk'
+
+  DaFunk::Test.configure do |t|
+    t.root_path = ROOT_PATH
+  end
+else
+  require "./lib/da_funk.rb"
+  require "test/unit"
+  require "./test/fixtures/platform.rb"
+end
+

data/test/unit/device/display_test.rb

@@ -0,0 +1,43 @@
+
+class DisplayTest < DaFunk::Test.case
+  def test_display_print
+    assert_equal nil, Device::Display.print("test")
+    assert_equal nil, Device::Display.print("test", 0)
+    assert_equal nil, Device::Display.print("test", 0, 0)
+  end
+
+  def test_display_print_line
+    assert_equal nil, Device::Display.print_line("test")
+    assert_equal nil, Device::Display.print_line("test", 0)
+    assert_equal nil, Device::Display.print_line("test", 0, 0)
+  end
+
+  def test_clear
+    assert_equal nil, Device::Display.clear
+    assert_equal nil, Device::Display.clear(2)
+  end
+
+  def test_print_bitmap
+    assert_raise File::FileError do
+      Device::Display.print_bitmap("test")
+    end
+  end
+
+  def test_kernel_print_line
+    assert_equal nil, print_line("test")
+    assert_equal nil, print_line("test", 0)
+    assert_equal nil, print_line("test", 0, 0)
+  end
+
+  def test_kernel_print
+    assert_equal nil, print("test")
+    assert_equal nil, print("test", 0)
+    assert_equal nil, print("test", 0, 0)
+  end
+
+  def test_kernel_puts
+    assert_equal nil, puts("test")
+    assert_equal nil, puts("test", 0)
+    assert_equal nil, puts("test", 0, 0)
+  end
+end

data/test/unit/device/helper_test.rb

@@ -0,0 +1,61 @@
+class HelperKlass
+  include Device::Helper
+end
+
+class HelperTest < DaFunk::Test.case
+  def setup
+    @helper = HelperKlass.new
+  end
+
+  def test_number_to_currency_basic
+    assert_equal  "0.00", @helper.number_to_currency("")
+    assert_equal  "0.01", @helper.number_to_currency("1")
+    assert_equal  "0.10", @helper.number_to_currency("10")
+    assert_equal  "0.01", @helper.number_to_currency("01")
+    assert_equal  "1.00", @helper.number_to_currency("100")
+    assert_equal "10.00", @helper.number_to_currency("1000")
+  end
+
+  def test_number_to_currency_separator
+    assert_equal "100.00", @helper.number_to_currency("10000", {:separator => "."})
+    assert_equal "100,00", @helper.number_to_currency("10000", {:separator => ","})
+  end
+
+  def test_number_to_currency_delimiter
+    assert_equal "1.000.00", @helper.number_to_currency("100000", {:delimiter => "."})
+    assert_equal "1,000.00", @helper.number_to_currency("100000", {:delimiter => ","})
+  end
+
+  def test_number_to_currency_precision
+    assert_equal "100.00", @helper.number_to_currency("10000", {:precision => 2})
+    assert_equal "10.000", @helper.number_to_currency("10000", {:precision => 3})
+    assert_equal "1,000.000", @helper.number_to_currency("1000000", {:precision => 3})
+  end
+
+  def test_number_to_currency_fixnum
+    assert_equal "100.00", @helper.number_to_currency(10000, {:precision => 2})
+    assert_equal "10.000", @helper.number_to_currency(10000, {:precision => 3})
+    assert_equal "1,000.000", @helper.number_to_currency(1000000, {:precision => 3})
+  end
+
+  def test_number_to_currency_float
+    assert_equal "100.00", @helper.number_to_currency(100.0, {:precision => 2})
+    assert_equal "100.000", @helper.number_to_currency(100.0, {:precision => 3})
+    assert_equal "10,000.000", @helper.number_to_currency(10000.0, {:precision => 3})
+  end
+
+  def test_number_to_currency_basic
+    assert_equal  "U$: 0.00", @helper.number_to_currency("",     {:label => "U$: "})
+    assert_equal  "U$: 0.01", @helper.number_to_currency("1",    {:label => "U$: "})
+    assert_equal  "U$: 0.10", @helper.number_to_currency("10",   {:label => "U$: "})
+    assert_equal  "U$: 0.01", @helper.number_to_currency("01",   {:label => "U$: "})
+    assert_equal  "U$: 1.00", @helper.number_to_currency("100",  {:label => "U$: "})
+    assert_equal "U$: 10.00", @helper.number_to_currency("1000", {:label => "U$: "})
+  end
+
+  def test_helper_include_scope
+    assert HelperKlass.methods.include? :attach
+    assert HelperKlass.new.methods.include? :attach
+  end
+end
+

data/test/unit/device/notification_callback_test.rb

@@ -0,0 +1,6 @@
+
+class NotificationCallbackTest < DaFunk::Test.case
+  def test_true
+    assert true
+  end
+end