ipcam 0.1.0

data/lib/ipcam/websock.rb

@@ -0,0 +1,380 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#
+# Sample for v4l2-ruby
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+require 'fileutils'
+require 'em-websocket'
+require 'msgpack/rpc/server'
+
+module IPCam
+  class WebSocket
+    include MessagePack::Rpc::Server
+
+    msgpack_options :symbolize_keys => true
+
+    class << self
+      #
+      # セッションリストの取得
+      #
+      # @return [Array<WebSocket>] セッションリスト
+      #
+      def session_list
+        return @session_list ||= []
+      end
+      private :session_list
+
+      #
+      # クリティカルセクションの設置
+      #
+      # @yield クリティカルセクションとして処理するブロック
+      #
+      # @return [Object] ブロックの戻り値
+      #
+      def sync(&proc)
+        return (@mutex ||= Mutex.new).synchronize(&proc)
+      end
+
+      #
+      # セッションリストへのセッション追加
+      #
+      # @param [Socket] sock  セッションリストに追加するソケットオブジェクト
+      #
+      # @return [WebSocket]
+      #   ソケットオブジェクトに紐付けられたセッションオブジェクト
+      #
+      # @note
+      #   受け取ったソケットオブジェクトを元に、セッションオブジェクトを
+      #   生成し、そのオブジェクトをセッションリストに追加する
+      #
+      def join(sock)
+        sync {
+          if session_list.any? {|s| s === sock}
+            raise("Already joined #{sock}")
+          end
+
+          ret = self.new(@app, sock)
+          session_list << ret
+
+          return ret
+        }
+      end
+      private :join
+
+      #
+      # セッションオブジェクトからのセッション削除
+      #
+      # @param [Socket] sock
+      #   セッションオブジェクトを特定するためのソケットオブジェクト
+      #
+      def bye(sock)
+        sync {
+          session_list.reject! { |s|
+            if s === sock
+              s.finish
+              true
+            else
+              false
+            end
+          }
+        }
+      end
+
+      #
+      # イベント情報の一斉送信
+      #
+      # @param [String] name  イベント名
+      # @param [Array] args イベントで通知する引数
+      #
+      def broadcast(name, *args)
+        sync {session_list.each {|s| s.notify(name, *args)}}
+      end
+
+      #
+      # バインド先のURL文字列を生成する
+      #
+      # @return [String] URL文字列
+      #
+      def bind_url
+        if $bind_addr.include?(":")
+          addr = "[#{$bind_addr}]" if $bind_addr.include?(":")
+        else
+          addr = $bind_addr
+        end
+
+        return "tcp://#{addr}:#{$http_port}"
+      end
+      private :bind_url
+
+      #
+      # WebSocket制御の開始
+      #
+      def start(app)
+        EM.defer {
+          @app = app
+
+          sleep 1 until EM.reactor_running?
+
+          $logger.info("websock") {"started (#{bind_url()})"}
+
+          EM::WebSocket.start(:host => $bind_addr, :port => $ws_port) { |sock|
+            peer = Socket.unpack_sockaddr_in(sock.get_peername)
+            addr = peer[1]
+            port = peer[0]
+            serv = join(sock)
+
+            sock.set_sock_opt(Socket::Constants::SOL_SOCKET,
+                              Socket::SO_KEEPALIVE,
+                              true)
+
+            sock.set_sock_opt(Socket::IPPROTO_TCP,
+                              Socket::TCP_QUICKACK,
+                              true)
+
+            sock.set_sock_opt(Socket::IPPROTO_TCP,
+                              Socket::TCP_NODELAY,
+                              false)
+
+            sock.onopen {
+              $logger.info("websock") {"connection from #{addr}:#{port}"}
+            }
+
+            sock.onbinary { |msg|
+              begin
+                serv.receive_dgram(msg)
+
+              rescue => e
+                $logger.error("websock") {
+                  "error occured: #{e.message} (#{e.backtrace[0]})"
+                }
+              end
+            }
+
+            sock.onclose {
+              $logger.info("websock") {
+                "connection close from #{addr}:#{port}"
+              }
+
+              bye(sock)
+            }
+          }
+        }
+      end
+    end
+
+    #
+    # セッションオブジェクトのイニシャライザ
+    #
+    # @param [IPCam] app  アプリケーション本体のインスタンス
+    # @param [Socket] sock Socketインスタンス
+    #
+    def initialize(app, sock)
+      @app   = app
+      @sock  = sock
+      @allow = []
+
+      peer   = Socket.unpack_sockaddr_in(sock.get_peername)
+      @addr  = peer[1]
+      @port  = peer[0]
+    end
+
+    attr_reader :sock
+
+    #
+    # セッションオブジェクトの終了処理
+    #
+    def finish
+    end
+
+    #
+    # peerソケットへのデータ送信
+    #
+    # @param [String] data  送信するデータ
+    #
+    # @note MessagePack::Rpc::Serverのオーバーライド
+    #
+    def send_data(data)
+      @sock.send_binary(data)
+    end
+    private :send_data
+
+    #
+    # MessagePack-RPCのエラーハンドリング
+    #
+    # @param [StandardError] e  発生したエラーの例外オブジェクト
+    #
+    # @note MessagePack::Rpc::Serverのオーバーライド
+    # 
+    def on_error(e)
+      $logger.error("websock") {e.message}
+    end
+    private :on_error
+
+    #
+    # 通知のブロードキャスト
+    #
+    # @param [String] name  イベント名
+    # @param [Array] args イベントで通知する引数
+    #
+    def broadcast(name, *args)
+      self.class.broadcast(name, *arg)
+    end
+    private :broadcast
+
+    #
+    # 通知の送信
+    #
+    # @param [String] name  イベント名
+    # @param [Array] args イベントで通知する引数
+    #
+    def notify(name, *args)
+      super(name, *args) if @allow == "*" or @allow.include?(name)
+    end
+
+    #
+    # 比較演算子の定義
+    #
+    def ===(obj)
+      return (self == obj || @sock == obj)
+    end
+
+    #
+    # RPC procedures
+    #
+
+		#
+		# 通知要求を設定する
+		#
+		# @param [Array] arg
+		#
+		# @return [:OK] 固定値
+		#
+		def add_notify_request(*args)
+			args.each {|type| @allow << type.to_sym}
+			args.uniq!
+
+			return :OK
+		end
+		remote_public :add_notify_request
+
+		#
+		# 通知要求をクリアする
+		#
+		# @param [Array] arg
+		#
+		# @return [:OK] 固定値
+		#
+		def clear_notify_request(*args)
+			args.each {|type| @allow.delete(type.to_sym)}
+
+			return :OK
+		end
+		remote_public :clear_notify_request
+
+    #
+    # 疎通確認用プロシジャー
+    #
+    # @return [:OK] 固定値
+    #
+    def hello
+      return :OK
+    end
+    remote_public :hello
+
+    #
+    # カメラ情報の取得
+    #
+    # @return [:OK] カメラ情報をパックしたハッシュ
+    #
+    def get_camera_info
+      return @app.get_camera_info()
+    end
+    remote_public :get_camera_info
+
+    #
+    # カメラ固有名の取得
+    #
+    # @return [:OK] カメラ情報をパックしたハッシュ
+    #
+    def get_ident_string
+      return @app.get_ident_string()
+    end
+    remote_public :get_ident_string
+
+    #
+    # カメラの設定情報の取得
+    #
+    # @return [Array] カメラの設定情報の配列
+    #
+    def get_config
+      return @app.get_config
+    end
+    remote_public :get_config
+
+    #
+    # 画像サイズの設定
+    #
+    # @param [Integer] width  新しい画像の幅
+    # @param [Integer] height 新しい画像の高さ
+    #
+    # @return [:OK] 固定値
+    #
+    # @note 画像サイズの変更に伴い、update_image_sizeイベントがブロード
+    #       キャストされる
+    #
+    def set_image_size(width, height)
+      @app.set_image_size(width, height)
+      return :OK
+    end
+    remote_public :set_image_size
+
+    #
+    # フレームレートの設定
+    #
+    # @param [Integer] num  新しいフレームレートの値（分子）
+    # @param [Integer] deno 新しいフレームレートの値（分母）
+    #
+    # @return [:OK] 固定値
+    #
+    # @note 画像サイズの変更に伴い、update_framerateイベントがブロード
+    #       キャストされる
+    #
+    def set_framerate(num, deno)
+      @app.set_framerate(num, deno)
+      return :OK
+    end
+    remote_public :set_framerate
+
+    #
+    # カメラの設定変更
+    #
+    # @param [Integer] id  設定項目のID
+    # @param [Integer] val 新しい設定項目の値
+    #
+    # @return [:OK] 固定値
+    #
+    # @note 画像サイズの変更に伴い、update_controlイベントがブロード
+    #       キャストされる
+    #
+    def set_control(num, deno)
+      @app.set_control(num, deno)
+      return :OK
+    end
+    remote_public :set_control
+
+    #
+    # 設定値の保存
+    #
+    # @return [:OK] 固定値
+    #
+    def save_config
+      @app.save_config()
+      return :OK
+    end
+    remote_public :save_config
+  end
+end

data/resource/common/js/msgpack-rpc.js

@@ -0,0 +1,191 @@
+/*
+ * MessagePack RPC base class
+ *
+ *  (C) 2017 Hiroshi Kuwagata <kgt9221@gmail.com>
+ */
+
+if (!msgpack) {
+  throw "msgpack-lite is not load yet"
+}
+
+(function () {
+  /* declar local symbol */
+  const newId       = Symbol('newId');
+  const callback    = Symbol('callback');
+  const recv        = Symbol('recv');
+
+  /* declar contant */
+  const DEFAULT_URL = `ws://${location.hostname}:${parseInt(location.port)+1}/`;
+  const COEDEC      = msgpack.createCodec({binarraybuffer:true, preset:true});
+  const ENC_OPT     = {codec:COEDEC};
+
+  msgpack.rpc = class {
+    /*
+     * core functions
+     */
+    constructor (url) {
+      this.url      = url || DEFAULT_URL
+      this.sock     = null;
+      this.deferred = null;
+      this.maxId    = 1;
+      this.handlers = {}
+    }
+
+    [newId]() {
+      return this.maxId++;
+    }
+
+    [callback](name, args) {
+      if (this.handlers[name]) {
+        this.handlers[name](...args);
+      } else {
+        throw `unhandled notification received (${name}).`;
+      }
+    }
+
+    [recv](data) {
+      var self;
+      var msg;
+      var type;
+      var id;
+      var meth;
+      var err;
+      var res;
+      var para;
+      var $df;
+
+      msg  = msgpack.decode(new Uint8Array(data), ENC_OPT);
+      type = msg[0];
+
+      switch (type) {
+      case 1:
+        id  = msg[1];
+        err = msg[2];
+        res = msg[3];
+        $df = this.deferred[id];
+
+        if ($df) {
+          if (err) {
+            $df.reject(err);
+          } else {
+            $df.resolve(res);
+          }
+        }
+
+        delete this.deferred[id];
+        break;
+
+      case 2:
+        meth = msg[1];
+        para = msg[2];
+
+        if (!para) {
+          para = [];
+        } else if (!(para instanceof Array)) {
+          para = [para];
+        }
+
+        this[callback](meth, para);
+        break;
+
+      default:
+        throw `Illeagal data (type=${type}) recevied.`;
+      }
+    }
+
+    remoteCall(meth) {
+      var id;
+      var $df;
+      var args;
+
+      id   = this[newId]();
+      $df  = new $.Deferred();
+      args = Array.prototype.slice.call(arguments, 1);
+
+      switch (args.length) {
+      case 0:
+        args = null;
+        break;
+
+      case 1:
+        args = args[0];
+        break;
+      }
+
+      this.deferred[id] = $df;
+      this.sock.send(msgpack.encode([0, id, meth, args], ENC_OPT));
+
+      return $df.promise();
+    }
+
+    remoteNotify(meth) {
+      var args;
+
+      args = Array.prototype.slice.call(arguments, 1);
+
+      switch (args.length) {
+      case 0:
+        args = null;
+        break;
+
+      case 1:
+        args = args[0];
+        break;
+      }
+
+      this.sock.send(msgpack.encode([2, meth, args], ENC_OPT));
+    }
+
+    on(name, func) {
+      this.handlers[name] = func;
+      return this;
+    }
+
+    start() {
+      var $df;
+
+      $df = new $.Deferred();
+
+      if (!this.sock) {
+        this.sock = new WebSocket(this.url);
+
+        this.sock.binaryType = "arraybuffer";
+
+        this.sock.onopen = () => {
+          this.deferred = {}
+          $df.resolve();
+        };
+
+        this.sock.onerror = () => {
+          $df.reject();
+        };
+
+        this.sock.onmessage = (m) => {
+          this[recv](m.data);
+        };
+
+        this.sock.onclose = () => {
+          if (this.onSessionClosed) this.onSessionClosed();
+          this.sock = null;
+        };
+      }
+
+      return $df.promise();
+    }
+
+    finish() {
+      var id;
+
+      this.sock.close();
+
+      for (id in this.deferred) {
+        this.deferred[id].reject("session finished");
+        delete this.deferred[id];
+      }
+
+      this.sock     = null;
+      this.deferred = null;
+    }
+  }
+})();
+

data/resource/common/js/util.js

@@ -0,0 +1,135 @@
+/*
+ * 雑多な処理を集めたコード
+ *
+ *  (C) 2017 Hiroshi Kuwagata <kgt9221@gmail.com>
+ */
+
+(function () {
+  function readJavaScript(src) {
+    return $.getScript(src);
+  }
+
+  function readCss(src) {
+    var $df;
+
+    $df = new $.Deferred();
+
+    $('head')
+      .append($('<link>')
+        .on('load', () => {
+          $df.resolve();
+        })
+        .attr("rel", "stylesheet")
+        .attr("type", "text/css")
+        .attr("href", src)
+      );
+
+    return $df.promise();
+  }
+
+  function getResource(list, $df) {
+    var src;
+
+    src = list.shift();
+
+    if (/\.js$/.test(src)) {
+      readJavaScript(src)
+        .then((script, state) => {
+          getResource(list, $df);
+        })
+        .fail((error) => {
+          $df.reject(error);
+        });
+
+    } else if (/\.(css|scss)$/.test(src)) {
+      readCss(src)
+        .then(() => {
+          getResource(list, $df);
+        })
+        .fail((error) => {
+          $df.reject(error);
+        });
+
+    } else if (src == null) {
+      $df.resolve();
+    }
+  }
+
+  function loadImage(url, dst) {
+    var $df;
+
+    $df = new $.Deferred();
+
+    if (!dst) {
+      dst = new Image();
+    } else {
+      if (dst instanceof jQuery) {
+        dst = dst[0];
+      }
+
+      if (!(dst instanceof Image)) {
+        throw("not image object");
+      }
+    }
+
+    $(dst)
+      .on('load', () => {
+        $df.resolve(dst);
+      })
+      .on('error', (e) => {
+        $df.reject(e);
+      })
+      .attr('src', url);
+
+    return $df.promise();
+  }
+
+  Utils = class {
+    static require(list) {
+      var $df;
+
+      $df = new $.Deferred()
+
+      getResource(list, $df);
+
+      return $df.promise();
+    }
+
+    static loadImageFromData(data) {
+      var $df;
+      var blob;
+      var url;
+
+      $df  = new $.Deferred();
+      blob = new Blob([data.data], {type: data.type});
+      url  = URL.createObjectURL(blob);
+
+      loadImage(url)
+        .then((img) => {
+          $df.resolve(img);
+        })
+        .fail((error) => {
+          $df.reject(error);
+        })
+        .always(() => {
+          URL.revokeObjectURL(url);
+        });
+
+      return $df.promise();
+    }
+
+    static copyToClipboard(text) {
+      var $text;
+
+      $text = $('<textarea>').css('visible', 'hidden');
+      $('body').append($text);
+
+      $text
+        .val(text)
+        .select();
+      document.execCommand('copy');
+
+      $text.remove();
+    }
+  }
+})();