rbitter 0.1.2-java

data/lib/rbitter/version.rb

@@ -0,0 +1,20 @@
+module Rbitter
+  PRODUCT_NAME = "Rbitter"
+  VERSION = "0.1.2"
+
+  def major
+    VERSION.match(/^([0-9]+)\./)[1]
+  end
+
+  def minor
+    VERSION.match(/\.([0-9]+)\./)[1]
+  end
+
+  def patchlv
+    VERSION.match(/\.([0-9]+)$/)[1]
+  end
+
+  def version_string
+    "#{PRODUCT_NAME} #{VERSION}"
+  end
+end

data/lib/rbitter/xmlrpc.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+#
+
+require "rbitter/xmlrpcd/xmlrpcd"

data/lib/rbitter/xmlrpcd/base.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module RPCHandles
+  RH_INFO = Struct.new("RPCHANDLE_INFO", :name, :version, :author, :description) {
+    def digest
+      "<rpchandle: #{name}-#{version} (written by #{author}, #{description})>"
+    end
+  }
+
+  module BaseHandle
+    # If a handler doesn't require an authorization, please inherit below class
+    class NoAuth < Object
+      def self.auth?
+        false
+      end
+    end
+
+    # If a handler does require an authorization, please inherit below class
+    class Auth < Object
+      def self.auth?
+        true
+      end
+    end
+  end
+end

data/lib/rbitter/xmlrpcd/rpchandles.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module RPCHandles
+  # Override this function will activate authentication feature.
+  # You can write and add RPCHandle. See 'rpc' folder.
+
+  @@auth_pool = nil
+  module_function
+  def auth
+    @@auth_pool
+  end
+end

data/lib/rbitter/xmlrpcd/xmlrpc_auth_server.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require "rbitter/xmlrpcd/rpchandles"
+require "rbitter/xmlrpcd/base"
+require "xmlrpc/server"
+require "webrick"
+
+module XMLRPC
+  class HTTPAuthXMLRPCServer < XMLRPC::WEBrickServlet
+    def extract_method(methodname, *args)
+      for name, obj in @handler
+        if obj.kind_of? Proc
+          next unless methodname == name
+        else
+          next unless methodname =~ /^#{name}(.+)$/
+          next unless obj.respond_to? $1
+          return obj.method($1)
+        end
+      end
+      nil
+    end
+
+    def service(request, response)
+      # Taken from xmlrpc/server.rb
+      if @valid_ip
+        raise WEBrick::HTTPStatus::Forbidden unless @valid_ip.any? { |ip| request.peeraddr[3] =~ ip }
+      end
+
+      if request.request_method != "POST"
+        raise WEBrick::HTTPStatus::MethodNotAllowed,
+              "unsupported method `#{request.request_method}'."
+      end
+
+      if parse_content_type(request['Content-type']).first != "text/xml"
+        raise WEBrick::HTTPStatus::BadRequest
+      end
+
+      length = (request['Content-length'] || 0).to_i
+
+      raise WEBrick::HTTPStatus::LengthRequired unless length > 0
+
+      data = request.body
+
+      if data.nil? or data.bytesize != length
+        raise WEBrick::HTTPStatus::BadRequest
+      end
+
+      # Originally, process(data) was here.
+      # We need to check whether a method requires authorization.
+      rpc_method_name, rpc_params = parser().parseMethodCall(data)
+      rpc_method = extract_method(rpc_method_name)
+
+      if RPCHandles.auth.nil?
+        resp = handle(rpc_method_name, *rpc_params)
+      else
+        if rpc_method.owner.ancestors.include?(RPCHandles::BaseHandle::Auth)
+          # Check cookie and check it's valid
+          if request.cookies.size == 1 \
+            and request.cookies[0].name == "auth_key" \
+            and RPCHandles.auth.include?(request.cookies[0].value)
+            resp = handle(rpc_method_name, *rpc_params)
+          else
+            # Permission required
+            raise WEBrick::HTTPStatus::Forbidden
+          end
+        elsif rpc_method.owner.ancestors.include?(RPCHandles::BaseHandle::NoAuth)
+          resp = handle(rpc_method_name, *rpc_params)
+        else
+          raise WEBrick::HTTPStatus::Forbidden
+        end
+      end
+
+      if resp.nil? or resp.bytesize <= 0
+        raise WEBrick::HTTPStatus::InternalServerError
+      end
+
+      response.status = 200
+      response['Content-Length'] = resp.bytesize
+      response['Content-Type']   = "text/xml; charset=utf-8"
+      response.body = resp
+    end
+  end
+end

data/lib/rbitter/xmlrpcd/xmlrpcd.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require "rbitter/xmlrpcd/rpchandles"
+require "rbitter/xmlrpcd/xmlrpc_auth_server"
+require "webrick"
+
+module Rbitter
+  RPC_PREFIX="rbitter"
+
+  class RPCServer
+    def initialize bind_host, bind_port
+      @server = WEBrick::HTTPServer.new(:Port => bind_port.to_i, :BindAddress => bind_host.to_s, :MaxClients => 4, :Logger => WEBrick::Log.new($stdout))
+      @core = XMLRPC::HTTPAuthXMLRPCServer.new
+      @core.set_default_handler { |name, *args|
+        "NO_COMMAND: #{name} with args #{args.inspect}"
+      }
+    end
+
+    def load_all_handles
+      Rbitter["xmlrpc"]["handles"].each { |path|
+        puts "[xmlrpc] Scanning handles from (#{path})"
+        Dir.entries(path).each { |fname|
+          fname = File.join(path, fname)
+          if File.exist?(fname) and File.file?(fname)
+            if fname.match(/rh_\w+\.rb$/)
+              begin
+                load fname
+              rescue Exception => e
+                # stub
+                puts "Exception while loading #{fname}"
+                puts e.inspect
+              end
+            else
+              puts "Ignored: #{fname}"
+            end
+          end
+        }
+      }
+
+      puts "[xmlrpc] found #{RPCHandles.constants.length} constants."
+      RPCHandles.constants.each { |handler|
+        if RPCHandles.const_get(handler).is_a?(Class)
+          @core.add_handler(RPC_PREFIX, RPCHandles.const_get(handler).new)
+        end
+      }
+    end
+
+    def main_loop
+      load_all_handles
+
+      @server.mount("/", @core)
+      @server.start
+
+      puts "[xmlrpc] XMLRPC started"
+    end
+  end
+
+  class DummyRPCServer
+    def initialize bind_host, bind_port; end
+
+    def load_all_handles; end
+
+    def main_loop
+      puts "[xmlrpc] DummyRPCServer started"
+    end
+  end
+
+  class NullRPCServer; end
+end

data/rbitter.gemspec

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rbitter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbitter"
+  spec.version       = Rbitter::VERSION
+  spec.authors       = ["Nidev Plontra"]
+  spec.email         = ["nidev.plontra@gmail.com"]
+  spec.summary       = %q{Rbitter is a Twitter client specialized in archiving}
+  spec.description   = %q{Rbitter archives all tweets appeared on user streaming using ActiveRecord. XMLRPC is used to serve archived tweets and useful features}
+  spec.homepage      = "https://github.com/nidev/rbitter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+
+  spec.add_dependency 'twitter', '~> 5.14'
+  spec.add_dependency 'json', '~> 1.7'
+  spec.add_dependency 'ripl', '~> 0.7'
+  spec.add_dependency 'activerecord', '~> 4.0'
+
+  if RUBY_PLATFORM == 'java'
+    spec.platform = 'java'
+
+    spec.add_dependency 'activerecord-jdbc-adapter', '~> 1.3'
+    spec.add_dependency 'jdbc-sqlite3', '~> 3.8'
+    spec.add_dependency 'jdbc-mysql', '~> 5.1'
+    spec.add_dependency 'activerecord-jdbcsqlite3-adapter', '~> 1.3'
+    spec.add_dependency 'activerecord-jdbcmysql-adapter', '~> 1.3'
+  else
+    spec.platform = 'ruby'
+
+    spec.add_dependency 'sqlite3', '~> 1.3'
+    spec.add_dependency 'mysql2', '~> 0.3'
+    spec.add_dependency 'activerecord-mysql2-adapter', '~> 0.0.3'
+  end
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/spec/config/default.json

@@ -0,0 +1,33 @@
+{
+  "twitter": {
+    "consumer_key": "",
+    "consumer_secret": "",
+    "access_token": "",
+    "access_token_secret": ""
+  },
+  "activerecord": "sqlite3",
+  "sqlite3": {
+    "dbfile": "rbitter.sqlite"
+  },
+  "mysql2": {
+    "host": "localhost",
+    "port": 3306,
+    "dbname": "archive",
+    "username": "",
+    "password": ""
+  },
+  "media_downloader": {
+    "cacert_path": "/cacerts/cacert.pem",
+    "download_dir": "imgs/"
+  },
+  "xmlrpc": {
+    "enable": true,
+    "bind_host": "0.0.0.0",
+    "bind_port": 1400,
+    "auth": {
+      "username": "username",
+      "password": "password"
+    },
+    "handles": ["/path/to/handles"]
+  }
+}

data/spec/rbitter/arcserver_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require "rbitter/arcserver"
+require "rbitter/streaming"
+require "rbitter/xmlrpcd/xmlrpcd"
+
+describe Rbitter::ArcServer do
+  it 'is presented' do
+    expect(Rbitter::ArcServer).to be_a(Class)
+  end
+
+  context 'With dummy implementations, ' do
+    before(:all) do
+      Rbitter.bootstrap(['configure'])
+      expect(File.file?('config.json')).to be(true)
+    end
+
+    it 'successfully returns from main_loop' do
+      Rbitter.config_initialize
+
+      arcserver = Rbitter::ArcServer.new(Rbitter::DummyRPCServer)
+      arcserver.main_loop(Rbitter::DummyStreamClient)
+    end
+
+    after(:all) do
+      File.delete('config.json') if File.exist?('config.json')
+      File.delete('rbitter.sqlite') if File.exist?('rbitter.sqlite')
+    end
+  end
+end

data/spec/rbitter/console_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require "rbitter/console"
+
+describe Rbitter::Console do
+  # TODO: Perform test...
+  it 'is presented' do
+    expect(Rbitter::Console).to be_a(Class)
+  end
+end

data/spec/rbitter/default/config_json_spec.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require "rbitter/default/config_json"

data/spec/rbitter/dlthread_spec.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require "rbitter/dlthread"
+
+describe Rbitter::DLThread do
+  it 'is presented' do
+    expect(Rbitter::DLThread).to be_a(Class)
+  end
+end

data/spec/rbitter/env_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require "rbitter"
+
+describe Rbitter do
+  it 'has env_reset function and clears Rbitter.env,' do
+    Rbitter.env_reset
+    expect(Rbitter.env).to be_a(Hash)
+    expect(Rbitter.env.length).to be(0)
+  end
+
+  context 'when config.json is not installed,' do
+    it 'fails on loading' do
+      expect{Rbitter.config_initialize}.to raise_error(Rbitter::ConfigFileError)
+    end
+  end
+
+  context 'when path to config.json is invalid,' do
+    it 'fals on loading' do
+      expect{Rbitter.config_initialize("/silly/dummy/.")}.to raise_error(Rbitter::ConfigFileError)
+    end
+  end
+
+
+  context 'when default config.json is installed,' do
+    before(:all) do
+      Rbitter.bootstrap(['configure'])
+      expect(File.file?('config.json')).to be(true)
+    end
+
+    it 'loads configuration successfully with autodetection' do
+      expect{Rbitter.config_initialize}.to_not raise_error
+      expect(Rbitter.env.length > 0).to be(true)
+    end
+
+    it 'loads configuration successfully with given config.json path' do
+      expect{Rbitter.config_initialize('config.json')}.to_not raise_error
+      expect(Rbitter.env.length > 0).to be(true)
+    end
+
+    it 'checks that Rbitter.env returns Hash' do
+      expect{Rbitter.config_initialize}.to_not raise_error
+      expect(Rbitter.env).to be_a(Hash)
+    end
+
+    it 'checks that Rbitter[] works' do
+      expect{Rbitter.config_initialize}.to_not raise_error
+      expect(Rbitter["twitter"]).to be_a(Hash)
+    end
+
+    after(:all) do
+      File.delete('config.json')
+    end
+  end
+
+  context 'when env_validator validates loaded configuration' do
+    # TODO: Perform test with spec/config/default.json
+    # TODO: Adding configuration validator on env.rb
+  end
+
+  # TODO: Perform test with spec/config/default.json
+end

data/spec/rbitter/libtwitter_connection_override_spec.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require "rbitter/libtwitter_connection_override"
+
+describe Rbitter do
+  it 'overrides twitter gem' do
+    expect(Twitter::Streaming::Connection::MODIFIED).to be(true)
+  end
+end

data/spec/rbitter/records_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require "rbitter/records"
+
+describe Rbitter::Record do
+  # TODO: Perform test...
+  it 'has ActiveRecord class named Record' do
+    expect(Rbitter::Record).to be_a(Class)
+  end
+
+  it 'has supportive module of ActiveRecord' do
+    expect(ARSupport).to be_a(Module)
+  end
+end