ji2p 0.0.3-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c6ad43332d52c304d8482dee58ac462f865cceae8742ba5671b18e2e325e5fde
+  data.tar.gz: 342d0f170fa8cc58e5aeca4d70d275ef1932cf91d16e1c3735d8a96c7e9803fc
+SHA512:
+  metadata.gz: 692d9be7fa913ddbfe34b0e21352d1faea776cf03272f15230f3f552eea01f266ca115c989d275267993737f744de73befc34aaea48141dcc22f9b13ad6708ca
+  data.tar.gz: d235b37aca3dda1489cc51590affb71333721fced136f2466ea35a9a882ea5a76980028011b610a6e971f199dab7e867a4c0ae06f46ea8963c2e304d155bd2a1

data/bin/bundle

@@ -0,0 +1,15 @@
+#!/usr/bin/env jruby
+# Exit cleanly from an early interrupt
+Signal.trap("INT") { exit 1 }
+
+require_relative "../lib/ji2p/environment"
+require_relative "../lib/ji2p/bundler"
+
+Ji2p::Bundler.setup!
+
+require "bundler/cli"
+require "bundler/friendly_errors"
+
+::Bundler.with_friendly_errors do
+  ::Bundler::CLI.start(ARGV, :debug => true)
+end

data/bin/ctxirb

@@ -0,0 +1,119 @@
+#!/usr/bin/env jruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup'
+lib = File.expand_path("../lib", __dir__)
+$:.unshift(lib) unless $LOAD_PATH.include?(lib)
+#puts $:
+
+#require 'active_support'
+#require 'active_support/core_ext'
+
+require 'irb'
+require 'irb/completion'
+require 'irb/ext/save-history'
+
+# Method to pretty-print object methods
+# Coded by sebastian delmont
+# http://snippets.dzone.com/posts/show/2916
+class Object
+  ANSI_BOLD       = "\033[1m"
+  ANSI_RESET      = "\033[0m"
+  ANSI_LGRAY    = "\033[0;37m"
+  ANSI_GRAY     = "\033[1;30m"
+  # Print object's methods
+  def pm(*options)
+    methods = self.methods
+    methods -= Object.methods unless options.include? :more
+    filter = options.select {|opt| opt.kind_of? Regexp}.first
+    methods = methods.select {|name| name =~ filter} if filter
+
+    data = methods.sort.collect do |name|
+      method = self.method(name)
+      if method.arity == 0
+        args = "()"
+      elsif method.arity > 0
+        n = method.arity
+        args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")})"
+      elsif method.arity < 0
+        n = -method.arity
+        args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")}, ...)"
+      end
+      klass = $1 if method.inspect =~ /Method: (.*?)#/
+        [name, args, klass]
+    end
+    max_name = data.collect {|item| item[0].size}.max
+    max_args = data.collect {|item| item[1].size}.max
+    data.each do |item|
+      print " #{ANSI_BOLD}#{item[0].to_s.rjust(max_name)}#{ANSI_RESET}"
+      print "#{ANSI_GRAY}#{item[1].ljust(max_args)}#{ANSI_RESET}"
+      print "   #{ANSI_LGRAY}#{item[2]}#{ANSI_RESET}\n"
+    end
+    data.size
+  end
+end
+
+module IRB # :nodoc:
+  def self.start_session(binding)
+    unless @__initialized
+      args = ARGV
+      ARGV.replace(ARGV.dup)
+      IRB.setup(nil)
+      ARGV.replace(args)
+      @__initialized = true
+    end
+
+    workspace = WorkSpace.new(binding)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+    @CONF[:SAVE_HISTORY] = 10000
+    @CONF[:HISTORY_FILE] = File.join(ENV['PWD'], '.irb-history')
+    @CONF[:BACK_TRACE_LIMIT] = 16
+    @CONF[:USE_READLINE] = true
+    @CONF[:AUTO_INDENT] = true
+    histfile = @CONF[:HISTORY_FILE]
+
+    #puts @CONF
+    maxsize = @CONF[:SAVE_HISTORY]
+
+    if File::exists?(histfile)
+      lines = IO::readlines(histfile).collect { |line| line.chomp }
+      puts "Read #{lines.nitems} saved history commands from '#{histfile}'." if $VERBOSE
+      Readline::HISTORY.push(*lines)
+    end
+
+    Kernel::at_exit do
+      lines = Readline::HISTORY.to_a.reverse.uniq.reverse
+      lines = lines[-maxsize, maxsize] if lines.length > maxsize
+      puts "Saving #{lines.length} history lines to '#{histfile}'."
+      File::open(histfile, File::WRONLY|File::CREAT|File::TRUNC) { |io| io.puts lines.join("\n") }
+    end
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+require 'ji2p'
+
+#Module.class_eval { def instance_methods(value);[];end } unless Module.methods.include? 'instance_methods'
+
+def reload!(print = true)
+  puts 'Reloading ...' if print
+  # Main project directory.
+  root_dir = File.expand_path('..', __dir__)
+  # Directories within the project that should be reloaded.
+  reload_dirs = %w{lib}
+  # Loop through and reload every file in all relevant project directories.
+  reload_dirs.each do |dir|
+    Dir.glob("#{root_dir}/#{dir}/**/*.rb").each { |f| load(f) }
+  end
+  # Return true when complete.
+  true
+end
+
+IRB.start_session(binding)
+

data/bin/simple_http_server

@@ -0,0 +1,20 @@
+#!/usr/bin/env jruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup'
+lib = File.expand_path("../lib", __dir__)
+$:.unshift(lib) unless $LOAD_PATH.include?(lib)
+#puts $:
+
+require 'ji2p'
+
+app = Proc.new { |env| ['200', {'Content-Type' => 'text/html'}, ['get rack\'d']] }
+
+kp = Ji2p::Control::Keypair.generate!
+ssmgr = Ji2p::Control::SocketManager.defineManager! "testing", kp
+ssmgr.connectTunnel
+socket = ssmgr.getServerSocket
+server = Ji2p::Server::HttpServer.new(app, socket)
+
+puts "Your destination: #{kp.dest.base32}"
+
+server.run

data/bin/simple_outproxy

@@ -0,0 +1,96 @@
+#!/usr/bin/env jruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup'
+lib = File.expand_path("../lib", __dir__)
+$:.unshift(lib) unless $LOAD_PATH.include?(lib)
+#puts $:
+
+require 'socket'
+require 'uri'
+require 'ji2p'
+
+class Proxy
+  def run socket
+    begin
+      @socket = socket
+
+      # Handle every request in another thread
+      loop do
+        s = @socket.accept
+        Thread.new s, &method(:handle_request)
+      end
+
+    # CTRL-C
+    rescue Interrupt
+      puts 'Got Interrupt..'
+    # Ensure that we release the socket on errors
+    ensure
+      if @socket
+        @socket.close
+        puts 'Socked closed..'
+      end
+      puts 'Quitting.'
+    end
+  end
+
+  def handle_request to_client
+    request_line = to_client.readline
+
+    verb    = request_line[/^\w+/]
+    url     = request_line[/^\w+\s+(\S+)/, 1]
+    version = request_line[/HTTP\/(1\.\d)\s*$/, 1]
+    uri     = URI::parse url
+
+    # Show what got requested
+    puts((" %4s "%verb) + url)
+
+    to_server = TCPSocket.new(uri.host, (uri.port.nil? ? 80 : uri.port))
+    to_server.write("#{verb} #{uri.path}?#{uri.query} HTTP/#{version}\r\n")
+
+    content_len = 0
+
+    loop do
+      line = to_client.readline
+
+      if line =~ /^Content-Length:\s+(\d+)\s*$/
+        content_len = $1.to_i
+      end
+
+      # Strip proxy headers
+      if line =~ /^proxy/i
+        next
+      elsif line.strip.empty?
+        to_server.write("Connection: close\r\n\r\n")
+
+        if content_len >= 0
+          to_server.write(to_client.read(content_len))
+        end
+
+        break
+      else
+        to_server.write(line)
+      end
+    end
+
+    buff = ""
+    loop do
+      to_server.read(4048, buff)
+      to_client.write(buff)
+      break if buff.size < 4048
+    end
+
+    # Close the sockets
+    to_client.close
+    to_server.close
+  end
+
+end
+
+
+kp = Ji2p::Control::Keypair.generate!
+ssmgr = Ji2p::Control::SocketManager.defineManager! "testing", kp
+ssmgr.connectTunnel
+socket = ssmgr.getServerSocket
+puts "Your destination: #{kp.dest.base32}"
+
+Proxy.new.run socket

data/lib/actor_system/actor.rb

@@ -0,0 +1,10 @@
+require 'digest/sha1'
+
+module ActorSystem
+  module Actor
+
+    def self.unique_id
+      Digest::SHA1.hexdigest([Time.now, rand].join)
+    end
+  end
+end

data/lib/actor_system/concurrent/processor.rb

@@ -0,0 +1,21 @@
+module ActorSystem
+  module Concurrent
+    class Processor
+      def self.start(concurrency = 1)
+        concurrency.times { |n| new("Processor #{n}") }
+      end
+
+      def initialize(name)
+        thread = Thread.new do
+          loop do
+            payload = Magique.backend.pop
+            worker_class = payload[:worker]
+            worker_class.new.perform(*payload[:args])
+          end
+        end
+
+        thread.name = name
+      end
+    end
+  end
+end

data/lib/actor_system/concurrent/worker.rb

@@ -0,0 +1,13 @@
+module ActorSystem
+  module Concurrent
+    module Worker
+      def self.backend
+        @backend
+      end
+
+      def self.backend=(backend)
+        @backend = backend
+      end
+    end
+  end
+end

data/lib/actor_system/core/minimal.rb

@@ -0,0 +1,84 @@
+require 'thread'
+
+module ActorSystem
+  module Minimal
+
+    module Actor  # To use this, you'd include Actor instead of Celluloid
+      module ClassMethods
+        def new(*args, &block)
+          Proxy.new(super)
+        end
+      end
+
+      class << self
+        def included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        def current
+          Thread.current[:actor]
+        end
+      end
+
+      class Proxy
+        def initialize(target)
+          @target  = target
+          @mailbox = Queue.new
+          @mutex   = Mutex.new
+          @running = true
+
+          @async_proxy = AsyncProxy.new(self)
+
+          @thread = Thread.new do
+            Thread.current[:actor] = self
+            process_inbox
+          end
+        end
+
+        def async
+          @async_proxy
+        end
+
+        def send_later(meth, *args)
+          @mailbox << [meth, args]
+        end
+
+        def terminate
+          @running = false
+        end
+
+        def method_missing(meth, *args)
+          process_message(meth, *args)
+        end
+
+        private
+
+        def process_inbox
+          while @running
+            meth, args = @mailbox.pop
+            process_message(meth, *args)
+          end
+
+        rescue Exception => ex
+          puts "Error while running actor: #{ex}"
+        end
+
+        def process_message(meth, *args)
+          @mutex.synchronize do
+            @target.public_send(meth, *args)
+          end
+        end
+      end
+
+      class AsyncProxy
+        def initialize(actor)
+          @actor = actor
+        end
+
+        def method_missing(meth, *args)
+          @actor.send_later(meth, *args)
+        end
+      end
+    end
+  end
+end

data/lib/actor_system/core/observable_implementation.rb

@@ -0,0 +1,58 @@
+module ActorSystem
+  module Core
+    module ObservableImplementation
+      def observers
+        @observers || @observers = []
+      end
+
+      def notify_observers(*args)
+        observers.each do |observer|
+          mutex.synchronize do
+            observer.observer_update(*args) if observer.respond_to? :observer_update
+          end
+        end
+      end
+
+      def add_observer(object)
+        mutex.synchronize do
+          observers << object
+        end
+      end
+
+      private
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+    end
+
+    class ObservableExample
+      include ObservableImplementation
+      attr_accessor :counter
+
+      def initialize
+        self.counter = 0
+      end
+
+      def tick
+        self.counter += 1
+        notify_observers(counter)
+      end
+    end
+
+    class ObserverExample
+      def initialize(observable)
+        observable.add_observer(self)
+      end
+
+      def observer_update(counter)
+        puts "Count has increased by: #{counter}"
+      end
+    end
+
+    # observable = Observable.new
+    # observer1 = Observer.new(observable)
+    # observer2 = Observer.new(observable)
+    # observable.tick
+  end
+end