multi_movingsign 0.0.1

data/lib/multi_movingsign/errors.rb

@@ -0,0 +1,10 @@
+module MultiMovingsign
+  class Error < StandardError
+
+  end
+
+  # Raised with invalid input
+  class InvalidInputError < Error
+
+  end
+end

data/lib/multi_movingsign/page_renderer.rb

@@ -0,0 +1,223 @@
+module MultiMovingsign
+  # Renders a page definition (Hash/YAML) into something that is easily displayable by the MovingsignApi (page solution)
+  class PageRenderer
+    DEFAULT_CHARACTER_WIDTH = 5
+
+    # @param page [Hash] page definition as a Hash
+    # @param options [Hash] options for the rendering operation
+    # @option options [Integer] :count the number of signs to render to (default: 1)
+    #
+    # @return [Hash] a page solution hash
+    def render(page, options = {})
+      # Vocabulary - Terms used here
+      #
+      # Sign
+      #     A single LED sign, stacked vertically with other LED signs...together forming a screen
+      # Screen
+      #     N LED signs stacked vertically.  Together they can display a screen of information at a time
+      # Page Definition
+      #     A page of information to be broken up and displayed on available signs, consisting of a title and n Line Definitions.
+      # Line Definition
+      #     A line of information from the page definition.  NOTE: a single line might turn into multiple screens of information
+      # Line Segment
+      #     A piece of a line definition, displayed on it's own sign, seprate from previous line segments of the same line.
+      #
+
+      signs_available = (options[:count] || 1)
+      page_title = page['title']
+      line_definitions = page['lines']
+      pin_title = signs_available > 1
+
+      page_definition = PageDefinition.from_hash page
+      page_segments = page_definition.calculate_segments(signs_available)
+      screens = page_segments.map { |s| s.calculate_screens(signs_available, screen_width) }.flatten
+
+      ## Preview Solution
+      #screens.each do |screen|
+      #  puts "----"
+      #  (0..(signs_available-1)).each do |i|
+      #    puts screen.line(i)
+      #  end
+      #end
+      #puts "----"
+
+      signs = (0..(signs_available-1)).map { |sign_index| {'content' => screens.map { |s| s.line(sign_index) }.join("\n")} }
+
+      {'signs' => signs, 'lines' => screens.length}
+    end
+
+    private
+
+    def screen_width
+      80
+    end
+
+    def self.calculate_width(string)
+      string.length * DEFAULT_CHARACTER_WIDTH
+    end
+  end
+
+  class PageDefinition
+    attr_accessor :title
+    attr_accessor :line_definitions
+
+    def self.from_hash(hash)
+      obj = self.new
+
+      obj.title = hash['title'] || ''
+      obj.line_definitions = hash['lines'].map { |ld| LineDefinition.from_hash ld }
+
+      obj
+    end
+
+    # Splits a {PageDefinition} into an array of {PageSegment}s
+    #
+    # @param signs [Integer] the number of signs (lines) available to render to
+    # @param options [Hash]
+    # @option options [Boolean] +:pin_title+
+    def calculate_segments(signs, options = {})
+      pin_title = signs > 1 && (options[:pin_title] != false)
+      page_segments = []
+      line_definitions = self.line_definitions.clone.reverse
+
+      index = 0
+      while !line_definitions.empty?
+        include_title = pin_title || index == 0             # include the title in this line segment?
+        line_count = include_title ? signs - 1 : signs      # number of line definitions to include in this page segment (less the title if included)
+
+        page_segments << PageSegment.new(include_title ? self.title : nil, line_definitions.pop(line_count).reverse)
+
+        index += 1
+      end
+
+      page_segments
+    end
+  end
+
+  class LineDefinition
+    attr_accessor :prefix
+    attr_accessor :line_segments
+
+    def self.from_hash(hash)
+      obj = self.new
+
+      obj.prefix = hash['prefix'] || nil
+      obj.line_segments = (hash['segments'] || hash['content'] || []).map { |segment| LineSegment.new(obj.prefix, segment) }
+
+      obj
+    end
+
+    def prefix?
+      !!self.prefix
+    end
+  end
+
+  class LineSegment
+    attr_accessor :prefix
+    attr_accessor :segment
+
+    def initialize(prefix, segment)
+      self.prefix = prefix
+      self.segment = segment
+    end
+
+    def prefix?
+      !!self.prefix
+    end
+
+    # If necessary, splits this LineSegment into multiple appropriate for displaying at once on the screen
+    def split_if_necessary(max_width)
+      raise InvalidInputError, "Prefix '' is too wide!" if (prefix? && PageRenderer.calculate_width(prefix) > max_width)
+
+      if PageRenderer.calculate_width(self.to_s) <= max_width
+        # segment isn't too long with prefix, return it as is
+        [self]
+      else
+        # segment is too long, split it up into word segments finding the largest with the prefix appended that fits
+        segments = []  # calculated segments
+        prefix_width = prefix? ? PageRenderer.calculate_width(prefix) : 0
+
+        words = segment.split(/ /)
+        while !words.empty?
+          index = words.length
+          while index > 0 && PageRenderer.calculate_width(candidate = (candidate_words = words[0, index]).join(' ')) + prefix_width > max_width
+            index -= 1
+          end
+
+          segments << self.class.new(prefix, candidate)
+          words = words.drop index
+        end
+
+        segments
+      end
+    end
+
+    def to_s
+      prefix? ? prefix + segment : segment
+    end
+
+    def inspect
+      to_s.inspect
+    end
+  end
+
+  class PageSegment
+    attr_accessor :title
+    attr_accessor :line_definitions
+
+    def initialize(title, line_definitions)
+      self.title = title
+      self.line_definitions = line_definitions
+    end
+
+    def title?
+      !!self.title
+    end
+
+    def line_definitions?
+      !self.line_definitions.empty?
+    end
+
+    # Turns a single page segment into n rendered screens of information
+    def calculate_screens(number_of_signs, sign_width)
+      raise "Title too long!" if title? && PageRenderer.calculate_width(title) >  sign_width
+
+      if title? && !line_definitions?
+        return Screen.new [title]
+      end
+
+      screens = []
+
+      #puts line_definitions.map { |d| d.line_segments.map { |s| s.split_if_necessary(sign_width).map { |s| s.to_s} } }.inspect
+
+      num_of_line_segments = line_definitions.map { |d| d.line_segments.length }.max
+      (0..(num_of_line_segments - 1)).each do |segment_index|
+        subsegments = line_definitions.map { |d| (s = d.line_segments[segment_index]) ? s.split_if_necessary(sign_width) : [] }
+        num_of_subsegments = subsegments.map { |s| s.length }.max
+
+        (0..(num_of_subsegments-1)).each do |subsegment_index|
+          lines = []
+
+          lines << title if title?
+          lines.concat subsegments.map { |s| s[subsegment_index % s.length] || "" }
+
+          screens << Screen.new(lines)
+        end
+      end
+
+      screens
+    end
+  end
+
+  class Screen
+    attr_accessor :lines
+
+    def initialize(lines)
+      self.lines = lines
+    end
+
+    def line(index)
+      self.lines[index] || " "
+    end
+  end
+end

data/lib/multi_movingsign/server.rb

@@ -0,0 +1,317 @@
+require 'thor'
+require 'thread'
+require 'socket'
+require 'multi_movingsign/signs'
+require 'multi_movingsign/testrc_loader'
+
+module MultiMovingsign
+  # http://stackoverflow.com/a/9439298
+  class TeeIO < IO
+    attr_accessor :destinations
+
+    def initialize(*dests)
+      self.destinations = dests
+    end
+
+    def puts(val)
+      time = Time.now
+      destinations.each do |d|
+        d.puts "#{time}: #{val.to_s}"
+        d.flush
+      end
+    end
+
+    def write(val)
+      destinations.each do |d|
+        d.write val
+        d.flush
+      end
+    end
+  end
+
+  # MultiMovingsign server command line interface
+  class Server < Thor
+  class_option :serverrc, :desc => 'Path to server persistent storage.  Defaults to ~/.multi_movingsign/server'
+    desc 'start', 'Starts the MutliMovingsign server'
+    def start
+      TestRCLoader.load(options['testrc']) if options['testrc']
+
+      # This impl is a hacky mess... FYI!
+      FileUtils.mkdir_p server_settings_path
+
+      lock_path = File.join(server_settings_path, "server.lock")
+      File.open(lock_path, 'w') do |lock|
+        raise "Cannot acquire lock! Is a server already running?" unless lock.flock(File::LOCK_EX | File::LOCK_NB)
+
+        lock.puts $$
+        lock.flush
+
+        mutex = Mutex.new
+
+        # setup logging
+        log_path = File.join(server_settings_path, "server.log")
+        log = File.new(log_path, "a")
+        $stdout = TeeIO.new($stdout, log)
+        $stderr = TeeIO.new($stderr, log)
+
+        signs = []
+
+        page_keys = []
+        page_solutions = {}
+        page_index = 0
+        alert = nil
+        stop = nil
+
+        Thread.new do
+          begin
+            Socket.unix_server_loop(server_socket_path) do |socket, address|
+              puts "SOCKET LOOP!"
+
+              begin
+                msg = nil
+
+                begin
+                  msg, = socket.recvmsg_nonblock
+                rescue IO::WaitReadable
+                  if IO.select([socket], [], [], 5)
+                    retry
+                  else
+                    raise TimeoutError, "Timeout in recvmsg_nonblock"
+                  end
+                end
+
+                unless msg
+                  $stderr.puts "Bogus unix_server_loop?"
+                  next
+                end
+
+                lines = msg.lines.map { |l| l.rstrip }
+                puts "Got UNIX message: #{lines.inspect}"
+
+                version = lines.delete_at 0
+
+                case command = lines.delete_at(0)
+                  when 'add page'
+                    name = lines.delete_at(0)
+                    yaml = lines.join "\n"
+
+                    solution = PageRenderer.new.render YAML.load(yaml), :count => signs.length
+                    page_path = File.join(server_pages_path, "#{name}.yml")
+                    File.open(page_path, "w") { |f| f.puts yaml }
+
+                    mutex.synchronize do
+                      page_solutions[name] = solution
+                      page_keys << name unless page_keys.include? name
+
+                      puts "Added #{name}!"
+
+                      page_keys.delete 'nada'
+                      page_solutions.delete 'nada'
+                    end
+
+                    socket.puts "okay"
+                  when 'delete page'
+                    name = lines.delete_at(0)
+
+                    mutex.synchronize do
+                      page_path = File.join(server_pages_path, "#{name}.yml")
+
+                      FileUtils.rm(page_path, :force => true) if File.exists? page_path
+
+                      page_keys.delete name
+                      page_solutions.delete name
+                    end
+
+                    puts "Deleted #{name}"
+
+                    socket.puts "okay"
+                  when 'alert'
+                    page_yaml = lines.join("\n")
+
+                    mutex.synchronize do
+                      condition_variable = ConditionVariable.new
+                      alert = {"solution" => PageRenderer.new.render(YAML.load(page_yaml), :count => signs.length), 'condition_variable' => condition_variable}
+
+                      puts "Signaling alert..."
+                      condition_variable.wait mutex
+                    end
+
+                    socket.puts "okay"
+
+                  when 'stop'
+                    mutex.synchronize do
+                      cv = ConditionVariable.new
+
+                      stop = {'condition_variable' => cv}
+
+                      cv.wait mutex
+                    end
+
+                    socket.puts "okay"
+                  else
+                    $stderr.puts "Unknown command '#{command}'"
+                end
+              rescue => e
+                $stderr.puts "Exception in unix server loop"
+                $stderr.puts e.message
+                $stderr.puts e.backtrace.join "\n"
+              ensure
+                socket.close
+                puts "SOCKET CLOSED"
+              end
+            end
+          rescue => e
+            $stderr.puts "UNIX socket loop raised!"
+            $stderr.puts e.message
+            $stderr.puts e.backtrace.join '\n'
+
+            Thread::current.pi
+          end
+        end
+
+        # Loop to allow reloaded
+        loop do
+          if stop
+            puts "Outter loop stopping..."
+            break
+          end
+
+          puts "Starting/Reloading!"
+
+          # load sign configuration
+          settings = Settings.load settings_path
+          raise_no_signs unless settings.signs?
+
+          mutex.synchronize do
+            page_keys = []
+            page_solutions = {}
+            signs = Signs.new settings.signs
+
+            # Load pages and solutions
+            FileUtils.mkdir_p server_pages_path
+            Dir.glob(File.join(server_pages_path, '*.yml')).sort.each do |path|
+              puts "Loading #{path}"
+
+              key = File.basename(path, File.extname(path))
+
+              page_keys << key
+              page_solutions[key] = PageRenderer.new.render YAML.load(File.read(path)), :count => signs.length
+            end
+
+            if page_keys.empty?
+              page_keys << 'nada'
+              page_solutions['nada'] = PageRenderer.new.render({'lines' => [{'prefix' => '', 'content' => ['No Pages']}, {'prefix' => '', 'content' => ['Configured']}]}, :count => signs.length)
+            end
+          end
+
+          # Loop through pages
+          loop do
+            if stop
+              puts "Inner loop stopping..."
+              break
+            end
+
+            page_key = nil
+            page_solution = nil
+
+            mutex.synchronize do
+              page_index = 0 if page_index >= page_keys.length || page_index < 0
+
+              # check for alert
+              if alert
+                page_key = 'ALERT'
+                page_solution = alert['solution']
+
+                page_index -= 1
+
+                # extract condition_variable
+                condition_variable = alert['condition_variable']
+
+                # clear alert
+                alert = nil
+
+                # signal that we got it!
+                condition_variable.signal
+              else
+                page_key = page_keys[page_index]
+                page_solution = page_solutions[page_key]
+              end
+            end
+
+            puts "Sending page #{page_key}"
+            signs.show_page_solution page_solution
+
+
+            sleep_amount = page_solution['lines'] && page_solution['lines'] * 3 * 2 || 20
+            sleep_amount = 20 if sleep_amount < 2
+
+            sleep sleep_amount
+
+            page_index += 1
+          end
+        end
+
+        if cv = stop && stop['condition_variable']
+          cv.signal
+          sleep 1     # wait a bit for the CV recipient to finish before we do.
+        end
+      end
+    end
+
+    desc 'add-page', 'Adds a page to the server rotation'
+    option :page, :required =>  true, :desc => "Path to page YAML"
+    option :name, :required =>  true, :desc => "Name for the new file"
+    def add_page
+      exit send_socket_command_expect_ok ['v1', 'add page', options[:name], File.read(options[:page])]
+    end
+
+    desc 'delete-page', 'Deletes a page to the server rotation'
+    option :name, :required =>  true, :desc => "Name for the new file"
+    def delete_page
+      exit send_socket_command_expect_ok ['v1', 'delete page', options[:name]]
+    end
+
+    desc 'alert', 'Sends a page to display as an alert'
+    option :page, :required =>  true, :desc => "Path to page YAML"
+    def alert
+      exit send_socket_command_expect_ok ['v1', 'alert', File.read(options[:page])]
+    end
+
+    desc 'stop', 'Stops the running server'
+    def stop
+      exit send_socket_command_expect_ok ['v1', 'stop']
+    end
+
+    private
+
+    def send_socket_command_expect_ok(args)
+      UNIXSocket.open server_socket_path do |socket|
+        send_socket_command(socket, args)
+        puts "Sent message...awaiting reply..."
+
+        (got = socket.gets) && got.strip == "okay" || false
+      end
+    end
+
+    def send_socket_command(socket, args)
+      socket.sendmsg args.join "\n"
+      socket.flush
+    end
+
+    def server_socket_path
+      File.join(server_settings_path, 'server.sock')
+    end
+
+    def server_settings_path
+      options[:serverrc] || File.join(ENV['HOME'], '.multi_movingsign', 'server')
+    end
+
+    def server_pages_path
+      File.join(server_settings_path, 'pages')
+    end
+
+    def settings_path
+      options[:rc] || Settings.default_settings_path
+    end
+  end
+end