frypan 0.0.1 → 1.0.0

data/_README.md

@@ -1,31 +0,0 @@
-# Frypan
-
-TODO: Write a gem description
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'frypan'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install frypan
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Contributing
-
-1. Fork it ( https://github.com/[my-github-username]/frypan/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request

data/bin/frypan

@@ -1,55 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
-# -*- mode: ruby -*-
-
-require 'mongo'
-
-def install(home_path)
-  # 1. mongodbのバイナリを落として [homepath]/mongodb.tarに保存
-  # 2. 解凍する。[homepath]/mongodb/bin/mongodってな具合になる
-  # 3. [homepath]/db/作る
-end
-
-def fork_db(home_path, port=27017)
-  mongod = "#{home_path}/mongodb/bin/mongod"
-  db = "#{home_path}/db/"
-  log = "#{home_path}/db/server.log"
-  status = `#{mongod} --dbpath #{db} --logpath #{log} --port #{port} --fork`
-  pid = status.lines.map{|ln| ln.match(/forked process: (\d+)/)}.select{|a| a}.first[1].to_i
-  success = status.lines.any?{|ln| ln.match(/successfully/)}
-  if success then pid else nil end
-end
-
-def connect_db(port=27017, host="localhost")
-  Mongo::Connection.new(host, port).db("frypan_core")
-end
-
-begin
-  pid = fork_db("~/Workspace/")
-  TinyFRP::Runtime.new(main_signal(connect_db)).run(:loop)
-ensure
-  Process.kill("TERM", pid) if pid
-end
-
-
-
-db = hoge
-api_server = APIServer.new(db) # fork webrick. only op-command throw.
-epg = hoge
-tuner = [fuga]
-
-command = TinyFRP.lift{ api_server.get_next_command } # one-unit-command OR nil
-current_time = TinyFRP.lift{ Time.now.strftime("%Y%m%d%H%M%S") }
-epg_flag = hoge
-tuners_flag = [fuga]
-
-main = TinyFRP::Bundle.new(command, current_time, epg_flag, tuners_flag) >> Node.top(setting)
-
-TinyFRP.loop(main) do |out|
-  out[:reserve1].action(db)
-  out[:reserve2].action(db)
-  out[:reserve3].action(db)
-  out[:reserve4].action(db)
-  out[:epg].action(epg)
-  out[:tuner1].action(tuner1)
-end

data/lib/frypan/database_sync_list.rb

@@ -1,30 +0,0 @@
-module Frypan
-  class DBSyncList
-    def initialize(name, db)
-      @coll = db.collection(name)
-    end
-
-    def +(list)
-      list.each{|a| @coll.insert(a)}
-      self
-    end
-
-    def update(alt_list)
-      @coll.remove
-      alt_list.each{|a| @coll.insert(a)}
-      self
-    end
-
-    def update_elements(elements, ident_key)
-      elements.each do |a|
-        @coll.update({ident_key => a[ident_key]}, {"$set" => a}, true)
-      end
-      self
-    end
-
-    def to_a
-      @coll.find.to_a
-    end
-  end
-end
-

data/lib/frypan/epg_parser.rb

@@ -1,23 +0,0 @@
-module Frypan
-  class EpgParser
-    require 'm2ts_parser'
-    class ParserProcess
-      def initialize(file_path)
-        
-      end
-
-      def finished?
-
-      end
-
-      def get_parsed
-
-      end
-    end
-
-    def parse(file_path)
-      ParserProcess.new(file_path)
-    end
-  end
-end
-

data/lib/frypan/node.rb

@@ -1,150 +0,0 @@
-module Frypan
-  require 'tiny_frp'
-  module Node
-    def self.overlaped?(list_of_range)
-      !list_of_range.sort{|a, b| a.begin <=> b.begin}.each_cons(2).all?{|a, b| a.end <= b.begin}
-    end
-
-    def self.apply_operations(list, ops)
-      case
-      when ops == []
-        [list, ""]
-      when ops.first[:kind] == :add
-        added_list = list + [ops.first[:target]]
-        if overlaped?(added_list.map{|a| a[:start_time]..a[:end_time]})
-          [nil, "cannot add reservation: #{ops.first[:target]}"]
-        else
-          apply_operations(added_list, ops.drop(1))
-        end
-      when ops.first[:kind] == :remove
-        if list.find{|a| a[:start_time] == ops.first[:target][:start_time]}
-          apply_operations(list.reject{|a| a[:start_time] == ops.first[:target][:start_time]}, ops.drop(1))
-        else
-          [nil, "unexist remove reservation id: #{ops.first[:target][:id]}"]
-        end
-      else
-        [nil, "unknown operation '#{ops.first[:kind]}'"]
-      end
-    end
-
-    def self.ReserveListFoldp(tuner_id, initial_list=[])
-      TinyFRP.foldp(launch: nil, list: initial_list, ack: nil) do |acc, command, current_time|
-        case
-        when command && command[:target_tuner] == tuner_id
-          new_list, status = *apply_operations(acc[:list], command[:operations])
-          ack = command.merge({
-             timestamp: current_time,
-             succeeded: !!new_list,
-             status: status
-           })
-          if new_list
-            {launch: nil, list: new_list.sort{|a, b| a[:start_time] <=> b[:start_time]}, ack: ack}
-          else
-            {launch: nil, ack: ack}
-          end
-        when acc[:list] != [] && acc[:list].first[:start_time] <= current_time
-          {launch: acc[:list].first, list: acc[:list].drop(1), ack: nil}
-        else
-          {launch: nil, ack: nil}
-        end
-      end
-    end
-
-    def self.PersistantReserveListFoldp(tuner_id, dbsync_reserve)
-      TinyFRP.foldp(last_list: nil, list: dbsync_reserve) do |acc, rlist|
-        if !acc[:last_list] || acc[:last_list] != rlist[:list]
-          {last_list: rlist[:list], list: acc[:list].update(rlist[:list])}
-        else
-          {}
-        end
-      end
-    end
-
-    def self.RecordingAsyncFoldp(tuner)
-      TinyFRP.foldp(busy: false, rec_process: nil, waiting: [], log: []) do |acc, rlist|
-        case
-        when rlist[:launch]
-          {waiting: acc[:waiting] + [rlist[:launch]], log: []}
-        when acc[:busy]
-          {busy: !acc[:rec_process].finished?, log: acc[:rec_process].get_log}
-        when acc[:waiting] != []
-          {
-            busy:        true,
-            rec_process: tuner.rec(acc[:waiting].first),
-            waiting:     acc[:waiting].drop(1),
-            log:         []
-          }
-        else
-          {log: []}
-        end
-      end
-    end
-
-    def self.RecordingLogFoldp(initial_log=[])
-      TinyFRP.foldp(log: initial_log, epg_order: [], recorded: []) do |acc, *log_inputs|
-        if log_inputs.any?{|a| a != []}
-          new_logs = log_inputs.select{|a| a != []}.flatten
-          {
-            log:       acc[:log] + new_logs,
-            epg_order: Fnc.find_epg_order(new_logs),
-            recorded:  Fnc.find_recorded(new_logs)
-          }
-        else
-          {epg_order: [], recorded: []}
-        end
-      end
-    end
-
-    def self.EpgExtractAsyncFoldp(epg_parser)
-      TinyFRP.foldp(busy: false, parser_process: nil, waiting: [], extracted: []) do |acc, log|
-        case
-        when log[:epg_order]
-          {waiting: acc[:waiting] + [log[:epg_order]], extracted: []}
-        when acc[:busy]
-          {busy: !acc[:parser_process].finished?, extracted: acc[:parser_process].get_parsed}
-        when acc[:waiting] != []
-          {
-            busy:           true,
-            parser_process: epg_parser.parse(acc[:waiting].first[:file_path]), 
-            waiting:        acc[:waiting].drop(1),
-            extracted:      []
-          }
-        else
-          {extracted: []}
-        end
-      end
-    end
-
-    def self.ProgramListFoldp(initial_list=[])
-      TinyFRP.foldp(list: initial_list) do |acc, epg|
-        if epg[:extracted] != []
-          # epg[:extracted] := list of {program_id: [service_id, event_id], ...}
-          {list: acc[:list].update_elements(epg[:extracted], :program_id)}
-        else
-          {}
-        end
-      end
-    end
-
-    def self.RecordedListFoldp(initial_list=[])
-      TinyFRP.foldp(list: initial_list) do |acc, log|
-        if log[:recorded] != []
-          {list: acc[:list] + log[:recorded]}
-        else
-          {}
-        end
-      end
-    end
-
-    def self.UIresponseFoldp(initial_list=[])
-      TinyFRP.foldp(list: initial_list) do |acc, current_time, *acks|
-        if acks.any?{|a| a}
-          {list: acc[:list] + acks.select{|a| a}}
-        else
-          {}
-        end
-      end
-    end
-  end
-end
-

data/lib/frypan/tuner.rb

@@ -1,47 +0,0 @@
-module Frypan
-  class Tuner
-    class RecordingProcess
-      def initialize(command)
-        @reader, writer = IO.pipe
-        @pid = Process.spawn(command, :err => writer, :out => writer)
-        @mutex = Mutex.new
-        @logs = []
-        Thread.new{
-          while IO::select([@reader])
-            @mutex.synchronize{
-              @logs << @reader.gets.chomp
-            }
-          end
-        }
-      end
-
-      def finished?
-        @finished ||= Process.waitpid2(@pid, Process::WNOHANG)
-      end
-
-      def get_log
-        res = []
-        @mutex.synchronize{
-          res = @logs.dup
-          @logs = []
-        }
-        res
-      end
-    end
-
-    def initialize(format_str)
-      @format_str = format_str
-    end
-
-    def rec(setting)
-      RecordingProcess.new(Tuner.make_command(@format_str, setting))
-    end
-
-    def self.make_command(format_str, setting)
-      setting.keys.inject(format_str) do |str, key|
-        str.gsub("<#{key}>", setting[key].to_s)
-      end
-    end
-  end
-end
-

data/unit_test/test_node.rb

@@ -1,171 +0,0 @@
-$LIBRARY_ROOT_PATH = File.dirname(File.expand_path(File.dirname(__FILE__)))
-
-module Frypan
-  module UnitTest
-    require 'test/unit'
-    require $LIBRARY_ROOT_PATH + '/lib/frypan/node.rb'
-
-    class DummyList
-      attr_reader :array
-      def initialize(init=[])
-        @array = []
-      end
-
-      def +(list)
-        DummyList.new(@array + list)
-      end
-
-      def update(alt_list)
-        DummyList.new(alt_list)
-      end
-
-      def update_elements(elements, ident_key)
-        if elements == []
-          self
-        else
-          update_element(elements.first, ident_key).update_elements(elements.drop(1), ident_key)
-        end
-      end
-
-      def update_element(element, ident_key)
-        if @array.find{|a| a[ident_key] == element[ident_key]}
-          DummyList.new(@array.map{|a| a[ident_key] == element[ident_key] ? element : a})
-        else
-          DummyList.new(@array + [element])
-        end
-      end
-    end
-
-    class DummyTuner
-      class DummyRecordingProcess
-        def initialize(logs)
-          @logs = logs.dup
-        end
-
-        def finished?
-          @logs.empty?
-        end
-        
-        def get_log
-          @logs.shift || []
-        end
-      end
-
-      def initialize(logs)
-        @logs = logs
-      end
-
-      def rec(setting)
-        DummyRecordingProcess.new(@logs)
-      end
-    end
-
-    class DummyEpgParser
-      class DummyParserProcess
-        def initialize(parseds)
-          @parseds = parseds.dup
-        end
-
-        def finished?
-          @parseds.empty?
-        end
-
-        def get_parsed
-          @parseds.shift || []
-        end
-      end
-
-      def initialize(parseds)
-        @parseds = parseds
-      end
-
-      def parse(file_path)
-        DummyParserProcess.new(@parseds)
-      end
-    end
-
-    module Util
-      def mkcom(command_id, target_tuner, *ops)
-        {command_id: command_id, target_tuner: target_tuner, operations: ops}
-      end
-
-      def mkop(kind, target)
-        {kind: kind, target: target}
-      end
-      
-      def mkres(id, start_time, end_time)
-        {id: id, start_time: start_time, end_time: end_time}
-      end
-    end
-
-    class NodeTest < Test::Unit::TestCase
-      include Util
-
-      def test_ReserveListFoldp
-        n = Node.ReserveListFoldp(:test_tuner, [])
-        vals = [
-                nil,
-                com1 = mkcom(0, :test_tuner, mkop(:add, res1 = mkres(0, 2, 5))),
-                com2 = mkcom(1, :test_tuner, mkop(:add, res2 = mkres(1, 5, 7))),
-                nil,
-                com3 = mkcom(2, :test_tuner, mkop(:add, res3 = mkres(2, 6, 10)))
-               ].each_with_index.map{|a, i| n.call(a, i)}
-
-        assert_equal({launch: nil, list: [], ack: nil}, vals[0])
-
-        expect_ack1 = com1.merge(timestamp: 1, succeeded: true, status: "")
-        assert_equal({launch: nil,  list: [res1], ack: expect_ack1}, vals[1])
-
-        expect_ack2 = com2.merge(timestamp: 2, succeeded: true, status: "")
-        assert_equal({launch: nil, list: [res1, res2], ack: expect_ack2}, vals[2])
-
-        assert_equal({launch: res1,  list: [res2], ack: nil}, vals[3])
-
-        expect_ack3 = com3.merge(timestamp: 4, succeeded: false, status: vals[4][:ack][:status])
-        assert_equal({launch: nil, list: [res2], ack: expect_ack3}, vals[4])
-      end
-
-      def test_PersistantReserveListFoldp
-        n = Node.PersistantReserveListFoldp(:tuner_tuner, DummyList.new([]))
-        vals = [
-                {list: [:a]},
-                {list: [:a]},
-                {list: [:a, :b]},
-               ].map{|a| n.call(a)}
-
-        assert_equal(vals[0], vals[1])
-        assert_not_equal(vals[1], vals[2])
-      end
-
-      def test_RecordingAsyncFoldp
-        n = Node.RecordingAsyncFoldp(DummyTuner.new([[0, 1], [2]]))
-        v = [
-             {launch: nil},
-             {launch: :a},
-             {launch: nil},
-             {launch: :b},
-             {launch: nil},
-             {launch: nil},
-             {launch: nil},
-             {launch: nil},
-             {launch: nil},
-             {launch: nil},
-             {launch: nil},
-            ].map{|a| n.call(a)}
-
-        assert_equal({busy: false, rec_process: v[0][:rec_process],  waiting: [],   log: []},     v[0])
-        assert_equal({busy: false, rec_process: v[1][:rec_process],  waiting: [:a], log: []},     v[1])
-        assert_equal({busy: true,  rec_process: v[2][:rec_process],  waiting: [],   log: []},     v[2])
-        assert_equal({busy: true,  rec_process: v[3][:rec_process],  waiting: [:b], log: []},     v[3])
-        assert_equal({busy: true,  rec_process: v[4][:rec_process],  waiting: [:b], log: [0, 1]}, v[4])
-        assert_equal({busy: true,  rec_process: v[5][:rec_process],  waiting: [:b], log: [2]},    v[5])
-        assert_equal({busy: false, rec_process: v[6][:rec_process],  waiting: [:b], log: []},     v[6])
-        assert_equal({busy: true,  rec_process: v[7][:rec_process],  waiting: [],   log: []},     v[7])
-        assert_equal({busy: true,  rec_process: v[8][:rec_process],  waiting: [],   log: [0, 1]}, v[8])
-        assert_equal({busy: true,  rec_process: v[9][:rec_process],  waiting: [],   log: [2]},    v[9])
-        assert_equal({busy: false, rec_process: v[10][:rec_process], waiting: [],   log: []},     v[10])
-      end
-    end
-  end
-end
-