socky 0.0.6

data/README

@@ -0,0 +1,10 @@
+socky_gem
+===========
+
+Socky is a WebSocket server and client for Ruby on Rails
+
+Please do not use it right now - it's unstable version so please wait for more stable(at last 0.1)
+
+=======
+
+Copyright (c) 2010 Bernard Potocki, released under the MIT license

data/Rakefile

@@ -0,0 +1,15 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "socky"
+    gemspec.summary = "Socky is a WebSocket server and client for Ruby on Rails"
+    gemspec.description = "Socky is a WebSocket server and client for Ruby on Rails"
+    gemspec.email = "b.potocki@imanel.org"
+    gemspec.homepage = "http://github.com/imanel/socky_gem"
+    gemspec.authors = ["Bernard Potocki"]
+    gemspec.add_dependency('em-websocket', '>= 0.0.6')
+    gemspec.files.exclude ".gitignore"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.6

data/bin/socky

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'socky')
+Socky::Runner.run

data/lib/em-websocket_hacks.rb

@@ -0,0 +1,11 @@
+EventMachine::WebSocket::Connection.class_eval do
+
+  def debug(*data)
+    if @debug
+      data.each do |d|
+        Socky.logger.debug "Socket " + d.collect{|dd| dd.to_s.gsub("\r\n","\n").gsub("\n","\\n")}.join(" ")
+      end
+    end
+  end
+
+end

data/lib/socky.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'logger'
+require 'fileutils'
+require 'em-websocket'
+require 'em-websocket_hacks'
+$:.unshift(File.dirname(__FILE__))
+
+module Socky
+
+  class SockyError < StandardError #:nodoc:
+  end
+
+  VERSION = File.read(File.dirname(__FILE__) + '/../VERSION').strip
+
+  @@options = {}
+
+  class << self
+    def options
+      @@options
+    end
+
+    def options=(val)
+      @@options = val
+    end
+
+    def logger
+      return @@logger if defined?(@@logger) && !@@logger.nil?
+      FileUtils.mkdir_p(File.dirname(log_path))
+      @@logger = Logger.new(log_path)
+      @@logger.level = Logger::INFO unless options[:debug]
+      @@logger
+    rescue
+      @@logger = Logger.new(STDOUT)
+      @@logger.level = Logger::INFO unless options[:debug]
+      @@logger
+    end
+
+    def logger=(logger)
+      @@logger = logger
+    end
+
+    def log_path
+      options[:log_path] || File.join(%w( / var run socky.log ))
+    end
+
+    def config_path
+      options[:config_path] || File.join(%w( / var run socky.yml ))
+    end
+  end
+end
+
+require 'socky/misc'
+require 'socky/options'
+require 'socky/runner'
+require 'socky/connection'
+require 'socky/net_request'
+require 'socky/server'
+require 'socky/message'

data/lib/socky/connection.rb

@@ -0,0 +1,84 @@
+require 'socky/connection/authentication'
+require 'socky/connection/finders'
+
+module Socky
+  class Connection
+    include Socky::Misc
+    include Socky::Connection::Authentication
+    include Socky::Connection::Finders
+
+    @@connections = []
+
+    attr_reader :socket
+
+    class << self
+      def connections
+        @@connections
+      end
+    end
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def admin
+      socket.request["Query"]["admin"] == "1"
+    end
+
+    def client
+      socket.request["Query"]["client_id"]
+    end
+
+    def secret
+      socket.request["Query"]["client_secret"]
+    end
+
+    def channels
+      @channels ||= socket.request["Query"]["channels"].to_s.split(",").collect(&:strip).reject(&:empty?)
+    end
+
+    def subscribe
+      debug [self.name, "incoming"]
+      subscribe_request
+    end
+
+    def unsubscribe
+      debug [self.name, "terminated"]
+      unsubscribe_request
+    end
+
+    def process_message(msg)
+      if admin
+        Socky::Message.process(self, msg)
+      else
+        self.send_message "You are not authorized to post messages"
+      end
+    end
+
+    def send_message(msg)
+      debug [self.name, "sending message", msg.inspect]
+      socket.send msg
+    end
+
+    def disconnect
+      socket.close_connection_after_writing
+    end
+
+    def add_to_pool
+      @@connections << self unless self.admin || @@connections.include?(self)
+    end
+
+    def remove_from_pool
+      @@connections.delete(self)
+    end
+
+    def to_json
+      {
+        :id => self.object_id,
+        :client_id => self.client,
+        :channels => self.channels
+      }.to_json
+    end
+
+  end
+end

data/lib/socky/connection/authentication.rb

@@ -0,0 +1,72 @@
+module Socky
+  class Connection
+    module Authentication
+
+      def subscribe_request
+        if authenticated?
+          debug [self.name, "authentication successed"]
+          add_to_pool
+        else
+          debug [self.name, "authentication failed"]
+          disconnect
+        end
+      end
+
+      def unsubscribe_request
+        if authenticated?
+          remove_from_pool
+          send_unsubscribe_request unless admin
+        end
+      end
+
+      def authenticated?
+        if @authenticated.nil?
+          @authenticated = (admin ? authenticate_as_admin : authenticate_as_user)
+        else
+          @authenticated
+        end
+      end
+
+      def authenticate_as_admin
+        true
+      end
+
+      def authenticate_as_user
+        authenticated_by_url?
+      end
+
+      def authenticated_by_url?
+        send_subscribe_request
+      end
+
+      def send_subscribe_request
+        subscribe_url = options[:subscribe_url]
+        if subscribe_url
+          debug [self.name, "sending subscribe request to", subscribe_url]
+          Socky::NetRequest.post(subscribe_url, params_for_request)
+        else
+          true
+        end
+      end
+
+      def send_unsubscribe_request
+        unsubscribe_url = options[:unsubscribe_url]
+        if unsubscribe_url
+          debug [self.name, "sending unsubscribe request to", unsubscribe_url]
+          Socky::NetRequest.post(unsubscribe_url, params_for_request)
+        else
+          true
+        end
+      end
+
+      def params_for_request
+        params = {}
+        params.merge!(:client_id => self.client) unless self.client.nil?
+        params.merge!(:client_secret => self.secret) unless self.secret.nil?
+        params.merge!(:channels => self.channels) unless self.channels.empty?
+        params
+      end
+
+    end
+  end
+end

data/lib/socky/connection/finders.rb

@@ -0,0 +1,50 @@
+module Socky
+  class Connection
+    module Finders
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def find_all
+          connections
+        end
+
+        def find(opts = {})
+          clients = opts[:clients].to_a
+          channels = opts[:channels].to_a
+          connections = find_all
+          connections = filter_by_clients(connections, clients) unless clients.empty?
+          connections = filter_by_channels(connections, channels) unless channels.empty?
+
+          connections
+        end
+
+        def find_by_clients(clients)
+          find(:clients => clients)
+        end
+
+        def find_by_channels(channels)
+          find(:channels => channels)
+        end
+
+        def find_by_clients_and_channels(clients, channels)
+          find(:clients => clients, :channels => channels)
+        end
+
+        private
+
+        def filter_by_clients(connections, clients)
+          connections.collect{ |con| con if clients.include? con.client }.compact
+        end
+
+        def filter_by_channels(connections, channels)
+          connections.collect{ |con| con if channels.any?{ |chan| con.channels.include?(chan) } }.compact
+        end
+
+      end
+
+    end
+  end
+end

data/lib/socky/message.rb

@@ -0,0 +1,94 @@
+require 'json'
+
+module Socky
+  class Message
+    include Socky::Misc
+
+    class UnauthorisedQuery < Socky::SockyError #:nodoc:
+    end
+
+    class InvalidBroadcast < Socky::SockyError #:nodoc:
+    end
+
+    class InvalidQuery < Socky::SockyError #:nodoc:
+    end
+
+    attr_reader :params, :creator
+
+    class << self
+      def process(connection, message)
+        m = new(connection, message)
+        m.process
+      rescue SockyError => e
+        error connection.name, e
+        m.respond e.message
+      end
+    end
+
+    def initialize(creator, message)
+      @params = symbolize_keys JSON.parse(message)
+      @creator = creator
+    end
+
+    def process
+      debug [self.name, "processing", params.inspect]
+
+      verify_secret!
+
+      case params[:command].to_sym
+        when :broadcast then broadcast
+        when :query then query
+      end
+    end
+
+    def verify_secret!
+      raise(UnauthorisedQuery, "invalid secret") unless options[:secret].nil? || options[:secret] == params[:secret]
+    end
+
+    def broadcast
+      case params[:type].to_sym
+        when :to_clients then broadcast_to_clients
+        when :to_channels then broadcast_to_channels
+        when :to_clients_on_channels then broadcast_to_clients_on_channels
+        else raise InvalidQuery, "unknown broadcast type"
+      end
+    end
+
+    def broadcast_to_clients
+      verify :clients
+      Socky::Server.send_to_clients(params[:body], params[:clients])
+    end
+
+    def broadcast_to_channels
+      verify :channels
+      Socky::Server.send_to_channels(params[:body], params[:channels])
+    end
+
+    def broadcast_to_clients_on_channels
+      verify :clients
+      verify :channels
+      Socky::Server.send_to_clients_on_channels(params[:body], params[:clients], params[:channels])
+    end
+
+    def query
+      case params[:type].to_sym
+        when :show_connections then query_show_connections
+        else raise InvalidQuery, "unknown query type"
+      end
+    end
+
+    def query_show_connections
+      respond Socky::Connection.find_all
+    end
+
+    def verify(field)
+      params[field] = params[field].to_a unless params[field].is_a?(Array)
+      params[field] = params[field].collect(&:to_s)
+    end
+
+    def respond(message)
+      creator.send_message(message.to_json)
+    end
+
+  end
+end

data/lib/socky/misc.rb

@@ -0,0 +1,48 @@
+module Socky
+  module Misc
+
+    def self.included(base)
+      base.extend Socky::Misc
+    end
+
+    def options
+      Socky.options
+    end
+
+    def options=(ob)
+      Socky.options = ob
+    end
+
+    def name
+      "#{self.class.to_s.split("::").last}(#{self.object_id})"
+    end
+
+    def log_path
+      Socky.log_path
+    end
+
+    def config_path
+      Socky.config_path
+    end
+
+    def info(args)
+      Socky.logger.info args.join(" ")
+    end
+
+    def debug(args)
+      Socky.logger.debug args.join(" ")
+    end
+
+    def error(name, error)
+      debug [name, "raised:", error.class, error.message]
+    end
+
+    def symbolize_keys(hash)
+      return self unless hash.is_a?(Hash)
+      hash.inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
+        options
+      end
+    end
+  end
+end

data/lib/socky/net_request.rb

@@ -0,0 +1,50 @@
+require 'timeout'
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'cgi'
+
+module Socky
+  class NetRequest
+    include Socky::Misc
+
+    class << self
+
+      def post(url, params = { })
+        uri = URI.parse(url)
+        params = params_from_hash(params)
+        headers = {"User-Agent" => "Ruby/#{RUBY_VERSION}"}
+        begin
+          http = Net::HTTP.new(uri.host, uri.port)
+          if uri.scheme == 'https'
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          http.read_timeout = options[:timeout] || 5
+          resp, data = http.post(uri.path, params, headers)
+          return resp.is_a?(Net::HTTPOK)
+        rescue => e
+          debug ["Bad request", url.to_s, e.class, e.message]
+          return false
+        rescue Timeout::Error
+          debug [url.to_s, "timeout"]
+          return false
+        end
+      end
+
+      def params_from_hash(params)
+        result = []
+        params.each do |key, value|
+          if value.is_a? Array
+            value.each{ |v| result << "#{key}[]=#{CGI::escape(v.to_s)}"}
+          else
+            result << "#{key}=#{CGI::escape(value.to_s)}"
+          end
+        end
+        result.join('&')
+      end
+
+    end
+
+  end
+end

data/lib/socky/options.rb

@@ -0,0 +1,29 @@
+require 'optparse'
+require 'yaml'
+require 'erb'
+require 'socky/options/config'
+require 'socky/options/parser'
+
+module Socky
+  module Options
+    include Socky::Options::Config
+    include Socky::Options::Parser
+
+    def prepare_options(argv)
+      self.options = {
+        :config_path => config_path
+      }
+
+      parse_options(argv)
+      read_config_file
+
+      self.options = {
+        :port => 8080,
+        :debug => false,
+        :deep_debug => false,
+        :log_path => log_path
+      }.merge(self.options)
+    end
+
+  end
+end

data/lib/socky/options/config.rb

@@ -0,0 +1,39 @@
+module Socky
+  module Options
+    module Config
+
+      def read_config_file
+        if !File.exists?(config_path)
+          puts "You must generate a config file (socky -g filename.yml)"
+          exit
+        end
+
+        self.options = YAML::load(ERB.new(IO.read(config_path)).result).merge!(self.options)
+      end
+
+      def generate_config_file
+        if File.exists?(config_path)
+          puts "Config file already exists. You must remove it before generating a new one."
+          exit
+        end
+        puts "Generating config file...."
+        File.open(config_path, 'w+') do |file|
+          file.write DEFAULT_CONFIG_FILE
+        end
+        puts "Config file generated at #{config_path}"
+        exit
+      end
+
+      DEFAULT_CONFIG_FILE= <<-EOF
+:port: 8080
+:debug: false
+
+:subscribe_url: http://localhost:3000/socky/subscribe
+:unsubscribe_url: http://localhost:3000/socky/unsubscribe
+
+:secret: my_secret_key
+EOF
+
+    end
+  end
+end

data/lib/socky/options/parser.rb

@@ -0,0 +1,60 @@
+module Socky
+  module Options
+    module Parser
+
+      def parse_options(argv)
+        OptionParser.new do |opts|
+          opts.summary_width = 25
+          opts.banner = "Usage: socky [options]\n"
+
+          opts.separator ""
+          opts.separator "Configuration:"
+
+          opts.on("-g", "--generate FILE", String, "Generate config file") do |v|
+            options[:config_path] = File.expand_path(v) if v
+            generate_config_file
+          end
+
+          opts.on("-c", "--config FILE", String, "Path to configuration file.", "(default: #{Socky.config_path})") do |v|
+            options[:config_path] = File.expand_path(v)
+          end
+
+          opts.separator ""; opts.separator "Network:"
+
+          opts.on("-p", "--port PORT", Integer, "Specify port", "(default: 8080)") do |v|
+            options[:port] = v
+          end
+
+          opts.separator ""; opts.separator "Logging:"
+
+          opts.on("-l", "--log FILE", String, "Path to print debugging information.", "(default: #{Socky.log_path})") do |v|
+            options[:log_path] = File.expand_path(v)
+          end
+
+          opts.on("--debug", "Run in debug mode") do
+            options[:debug] = true
+          end
+
+          opts.on("--deep-debug", "Run in debug mode that is even more verbose") do
+            options[:debug] = true
+            options[:deep_debug] = true
+          end
+
+          opts.separator ""; opts.separator "Miscellaneous:"
+
+          opts.on_tail("-?", "--help", "Display this usage information.") do
+            puts "#{opts}\n"
+            exit
+          end
+
+          opts.on_tail("-v", "--version", "Display version") do |v|
+            puts "Socky #{VERSION}"
+            exit
+          end
+        end.parse!(argv)
+        options
+      end
+
+    end
+  end
+end

data/lib/socky/runner.rb

@@ -0,0 +1,45 @@
+module Socky
+  class Runner
+    include Socky::Misc
+    include Socky::Options
+
+    class << self
+      def run(argv = ARGV)
+        self.new(argv)
+      end
+    end
+
+    def initialize(argv = ARGV)
+      prepare_options(argv)
+      start
+    end
+
+    def start
+      EventMachine.epoll
+
+      EventMachine.run do
+
+        trap("TERM") { stop }
+        trap("INT")  { stop }
+
+        EventMachine::start_server("0.0.0.0", options[:port],
+            EventMachine::WebSocket::Connection, :debug => options[:deep_debug]) do |ws|
+
+          connection = Socky::Connection.new(ws)
+          ws.onopen    { connection.subscribe }
+          ws.onmessage { |msg| connection.process_message(msg) }
+          ws.onclose   { connection.unsubscribe }
+
+        end
+
+        info ["Server started"]
+      end
+    end
+
+    def stop
+      info ["Server stopping"]
+      EventMachine.stop
+    end
+
+  end
+end

data/lib/socky/server.rb

@@ -0,0 +1,28 @@
+module Socky
+  class Server
+    include Socky::Misc
+
+    class << self
+
+      def send_to_clients(message, clients)
+        connections = Socky::Connection.find_by_clients(clients)
+        send_data(message, connections)
+      end
+
+      def send_to_channels(message, channels)
+        connections = Socky::Connection.find_by_channels(channels)
+        send_data(message, connections)
+      end
+
+      def send_to_clients_on_channels(message, clients, channels)
+        connections = Socky::Connection.find_by_clients_and_channels(clients, channels)
+        send_data(message, connections)
+      end
+
+      def send_data(message, connections)
+        connections.each{|c| c.send_message message}
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: socky
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 6
+  version: 0.0.6
+platform: ruby
+authors: 
+- Bernard Potocki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-24 00:00:00 +02:00
+default_executable: socky
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: em-websocket
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 6
+        version: 0.0.6
+  type: :runtime
+  version_requirements: *id001
+description: Socky is a WebSocket server and client for Ruby on Rails
+email: b.potocki@imanel.org
+executables: 
+- socky
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- VERSION
+- bin/socky
+- lib/em-websocket_hacks.rb
+- lib/socky.rb
+- lib/socky/connection.rb
+- lib/socky/connection/authentication.rb
+- lib/socky/connection/finders.rb
+- lib/socky/message.rb
+- lib/socky/misc.rb
+- lib/socky/net_request.rb
+- lib/socky/options.rb
+- lib/socky/options/config.rb
+- lib/socky/options/parser.rb
+- lib/socky/runner.rb
+- lib/socky/server.rb
+has_rdoc: true
+homepage: http://github.com/imanel/socky_gem
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Socky is a WebSocket server and client for Ruby on Rails
+test_files: []
+