jubilee 2.1.0.rc1-java → 3.0.0.beta2-java

data/lib/core/dns.rb

@@ -1,143 +0,0 @@
-# Copyright 2013 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'core/wrapped_handler'
-require 'socket'
-
-module Vertx
-
-  MxRecord =  Struct.new(:priority, :name)
-  SrvRecord =  Struct.new(:priority, :weight, :port, :name, :protocol, :service, :target)
-
-  # An async DNS Client
-  #
-  # @author Norman Maurer
-  class DnsClient
-    def initialize(*servers)
-      @j_dns = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createDnsClient(
-          servers.map { |value| java.net.InetSocketAddress.new(value.ip_address, value.ip_port) }.to_java(java.net.InetSocketAddress))
-    end
-
-    # Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name. The first found will be used.
-    # The handler will be notified once the lookup completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def lookup(name, &hndlr)
-      @j_dns.lookup(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostAddress()})
-      self
-    end
-
-    # Try to lookup the A (ipv4) record for the given name. The first found will be used.
-    # The handler will be notified once the lookup completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def lookup_4(name, &hndlr)
-      @j_dns.lookup4(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostAddress()})
-      self
-    end
-
-    # Try to AAAA (ipv6) record for the given name. The first found will be used.
-    # The handler will be notified once the lookup completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def lookup_6(name, &hndlr)
-      @j_dns.lookup6(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostAddress()})
-      self
-    end
-
-    # Try to resolve all A records for the given name.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def resolve_a(name, &hndlr)
-      @j_dns.resolveA(name, ARWrappedHandler.new(hndlr) { |j_list|
-        j_list.map { |item|
-          item.getHostAddress()
-        }
-      })
-      self
-    end
-
-    # Try to resolve all AAAA records for the given name.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def resolve_aaaa(name, &hndlr)
-      @j_dns.resolveAAAA(name, ARWrappedHandler.new(hndlr) { |j_list|
-        j_list.map { |item|
-          item.getHostAddress()
-        }
-      })
-      self
-    end
-
-    # Try to resolve all CNAME records for the given name.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def resolve_cname(name, &hndlr)
-      @j_dns.resolveCNAME(name, ARWrappedHandler.new(hndlr))
-      self
-    end
-
-    # Try to resolve all MX records for the given name.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def resolve_mx(name, &hndlr)
-      @j_dns.resolveMX(name, ARWrappedHandler.new(hndlr) { |j_list|
-        j_list.map { |item|
-          MxRecord.new(item.priority(), item.name())
-        }
-      })
-      self
-    end
-
-    # Try to resolve the PTR record for the given name.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def resolve_ptr(name, &hndlr)
-      @j_dns.resolvePTR(name, ARWrappedHandler.new(hndlr))
-      self
-    end
-
-    # Try to resolve all NS records for the given name.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def resolve_ns(name, &hndlr)
-      @j_dns.resolveNS(name, ARWrappedHandler.new(hndlr))
-      self
-    end
-
-    def resolve_txt(name, &hndlr)
-      @j_dns.resolveTXT(name, ARWrappedHandler.new(hndlr))
-      self
-    end
-
-    # Try to resolve all SRV records for the given name.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def resolve_srv(name, &hndlr)
-      @j_dns.resolveSRV(name, ARWrappedHandler.new(hndlr) { |j_list|
-        j_list.map { |item|
-          SrvRecord.new(item.priority(), item.weight(), item.port(), item.name(), item.protocol(), item.service(), item.target())
-        }
-      })
-      self
-    end
-
-    # Try to do a reverse lookup of an ipaddress. This is basically the same as doing trying to resolve a PTR record
-    # but allows you to just pass in the ipaddress and not a valid ptr query string.
-    # The handler will be notified once the operation completes.
-    # @param [Block] hndlr A block to be used as the handler
-    def reverse_lookup(name, &hndlr)
-      @j_dns.reverseLookup(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostName()})
-      self
-    end
-
-  end
-end

data/lib/core/event_bus.rb

@@ -1,277 +0,0 @@
-# Copyright 2011 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'rubygems'
-require 'json'
-
-module Vertx
-
-  # This class represents a distributed lightweight event bus which can encompass multiple vert.x instances.
-  # It is very useful for otherwise isolated vert.x application instances to communicate with each other.
-  #
-  # The event bus implements both publish / subscribe network and point to point messaging.
-  #
-  # For publish / subscribe, messages can be published to an address using one of the publish methods. An
-  # address is a simple String instance. Handlers are registered against an address. There can be multiple handlers
-  # registered against each address, and a particular handler can be registered against multiple addresses.
-  # The event bus will route a sent message to all handlers which are registered against that address.
-
-  # For point to point messaging, messages can be sent to an address using the send method.
-  # The messages will be delivered to a single handler, if one is registered on that address. If more than one
-  # handler is registered on the same address, Vert.x will choose one and deliver the message to that. Vert.x will
-  # aim to fairly distribute messages in a round-robin way, but does not guarantee strict round-robin under all
-  # circumstances.
-  #
-  # All messages sent over the bus are transient. On event of failure of all or part of the event bus messages
-  # may be lost. Applications should be coded to cope with lost messages, e.g. by resending them,
-  # and making application services idempotent.
-  #
-  # The order of messages received by any specific handler from a specific sender should match the order of messages
-  # sent from that sender.
-  #
-  # When sending a message, a reply handler can be provided. If so, it will be called when the reply from the receiver
-  # has been received. Reply messages can also be replied to, etc, ad infinitum.
-  #
-  # Different event bus instances can be clustered together over a network, to give a single logical event bus.
-  #
-  # When receiving a message in a handler the received object is an instance of EventBus::Message - this contains
-  # the actual message plus a reply method which can be used to reply to it.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class EventBus
-
-    @@handler_map = {}
-
-    @@j_eventbus = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.eventBus()
-
-    # Send a message on the event bus
-    # @param message [Hash] The message to send
-    # @param reply_handler [Block] An optional reply handler.
-    # @param [Integer] timeout if specified sends the message
-    # It will be called when the reply from a receiver is received.
-    def EventBus.send(address, message, timeout = nil, &reply_handler)
-
-      if timeout.nil?
-        EventBus.send_or_pub(true, address, message, reply_handler)
-      else
-        EventBus.send_or_pub(true, address, message, reply_handler, timeout)
-      end
-
-      self
-    end
-
-    # Sets a default timeout, in ms, for replies. If a messages is sent specify a reply handler
-    # but without specifying a timeout, then the reply handler is timed out, i.e. it is automatically unregistered
-    # if a message hasn't been received before timeout.
-    # The default value for default send timeout is -1, which means "never timeout".
-    # @param timeout
-    def EventBus.default_reply_timeout=(timeout)
-      @@j_eventbus.setDefaultReplyTimeout(timeout)
-      self
-    end
-
-    # Gets the default reply timeout value
-    def EventBus.default_reply_timeout
-      @@j_eventbus.getDefaultReplyTimeout
-    end
-
-    # Publish a message on the event bus
-    # @param message [Hash] The message to publish
-    def EventBus.publish(address, message)
-      EventBus.send_or_pub(false, address, message)
-      self
-    end
-
-    # @private
-    def EventBus.send_or_pub(send, address, message, reply_handler = nil, timeout = nil)
-      raise "An address must be specified" if !address
-      raise "A message must be specified" if message == nil
-      message = convert_msg(message)
-      if send
-        if reply_handler != nil
-          if timeout != nil
-            @@j_eventbus.send_with_timeout address, message, timeout, AsyncInternalHandler.new(reply_handler)
-          else
-            @@j_eventbus.send(address, message, InternalHandler.new(reply_handler))
-          end
-        else
-          @@j_eventbus.send(address, message)
-        end
-      else
-        @@j_eventbus.publish(address, message)
-      end
-      self
-    end
-
-    # Register a handler.
-    # @param address [String] The address to register for. Messages sent to that address will be
-    # received by the handler. A single handler can be registered against many addresses.
-    # @param local_only [Boolean] If true then handler won't be propagated across cluster
-    # @param message_hndlr [Block] The handler
-    # @return [FixNum] id of the handler which can be used in {EventBus.unregister_handler}
-    def EventBus.register_handler(address, local_only = false, &message_hndlr)
-      raise "An address must be specified" if !address
-      raise "A message handler must be specified" if !message_hndlr
-      internal = InternalHandler.new(message_hndlr)
-      if local_only
-        @@j_eventbus.registerLocalHandler(address, internal)
-      else
-        @@j_eventbus.registerHandler(address, internal)
-      end
-      id = java.util.UUID.randomUUID.toString
-      @@handler_map[id] = [address, internal]
-      id
-    end
-
-    # Registers a handler against a uniquely generated address, the address is returned as the id
-    # received by the handler. A single handler can be registered against many addresses.
-    # @param local_only [Boolean] If true then handler won't be propagated across cluster
-    # @param message_hndlr [Block] The handler
-    # @return [FixNum] id of the handler which can be used in {EventBus.unregister_handler}
-    def EventBus.register_simple_handler(local_only = false, &message_hndlr)
-      raise "A message handler must be specified" if !message_hndlr
-      internal = InternalHandler.new(message_hndlr)
-      id = java.util.UUID.randomUUID.toString
-      if local_only
-        @@j_eventbus.registerLocalHandler(id, internal)
-      else
-        @@j_eventbus.registerHandler(id, internal)
-      end
-      @@handler_map[id] = [id, internal]
-      id
-    end
-
-    # Unregisters a handler
-    # @param handler_id [FixNum] The id of the handler to unregister. Returned from {EventBus.register_handler}
-    def EventBus.unregister_handler(handler_id)
-      raise "A handler_id must be specified" if !handler_id
-      tuple = @@handler_map.delete(handler_id)
-      raise "Cannot find handler for id #{handler_id}" if !tuple
-      @@j_eventbus.unregisterHandler(tuple.first, tuple.last)
-      self
-    end
-
-    # @private
-    def EventBus.convert_msg(message)
-      if message.is_a? Hash
-        message = org.vertx.java.core.json.JsonObject.new(JSON.generate(message))
-      elsif message.is_a? Buffer
-        message = message._to_java_buffer
-      elsif message.is_a? Fixnum
-        message = java.lang.Long.new(message)
-      elsif message.is_a? Float
-        message = java.lang.Double.new(message)
-      end
-      message
-    end
-
-  end
-
-  # @private
-  class InternalHandler
-    include org.vertx.java.core.Handler
-
-    def initialize(hndlr)
-      @hndlr = hndlr
-    end
-
-    def handle(message)
-      @hndlr.call(Message.new(message))
-    end
-  end
-
-
-  # Represents a message received from the event bus
-  # @author {http://tfox.org Tim Fox}
-  class Message
-
-    attr_reader :body
-
-    # @private
-    def initialize(message)
-
-      @j_del = message
-      if message.body.is_a? org.vertx.java.core.json.JsonObject
-        @body = JSON.parse(message.body.encode)
-      elsif message.body.is_a? org.vertx.java.core.buffer.Buffer
-        @body = Buffer.new(message.body)
-      else
-        @body = message.body
-      end
-    end
-
-    # Reply to this message. If the message was sent specifying a receipt handler, that handler will be
-    # called when it has received a reply. If the message wasn't sent specifying a receipt handler
-    # this method does nothing.
-    # Replying to a message this way is equivalent to sending a message to an address which is the same as the message id
-    # of the original message.
-    # @param [Hash] Message send as reply
-    def reply(reply, timeout = nil, &reply_handler)
-      raise "A reply message must be specified" if reply == nil
-      reply = EventBus.convert_msg(reply)
-      if reply_handler != nil
-        if timeout != nil
-          @j_del.reply_with_timeout reply, timeout, AsyncInternalHandler.new(reply_handler)
-        else
-          @j_del.reply(reply, InternalHandler.new(reply_handler))
-        end
-      else
-        @j_del.reply(reply)
-      end
-    end
-
-    # Gets the address the message was sent to
-    # @return [String] The recipient's address
-    def address
-      @j_del.address
-    end
-
-    def fail(failure_code, message)
-      @j_del.fail failure_code, message
-    end
-
-  end
-
-
-  # Error when the event bus use timeout and doesn't reply in time
-  # Copied from mod-lang-jython
-  class ReplyError
-
-    TIMEOUT = 0
-    NO_HANDLERS = 1
-    RECIPIENT_FAILURE = 2
-
-    def initialize(exception)
-      @exception = exception
-    end
-    def type
-      @exception.failureType().toInt()
-    end
-  end
-
-  # Copied from mod-lang-jython
-  class AsyncInternalHandler
-    include org.vertx.java.core.AsyncResultHandler
-    def initialize(hndlr)
-      @hndlr = hndlr
-    end
-    def handle(result)
-      if result.failed?
-        @hndlr.call(ReplyError.new(result.cause))
-      else
-        @hndlr.call(Message.new(result.result))
-      end
-    end
-  end
-end

data/lib/core/file_system.rb

@@ -1,479 +0,0 @@
-# Copyright 2011 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'core/streams'
-require 'core/wrapped_handler.rb'
-
-module Vertx
-
-  # Represents the properties of a file on the file system
-  # @author {http://tfox.org Tim Fox}
-  class FileProps
-
-    # @private
-    def initialize(j_props)
-      @j_props = j_props
-    end
-
-    # @return [Time] The creation time of the file.
-    def creation_time
-      Time.at(@j_props.creationTime.getTime() / 1000)
-    end
-
-    # @return [Time] The last access time of the file.
-    def last_access_time
-      Time.at(@j_props.lastAccessTime.getTime() / 1000)
-    end
-
-    # @return [Time] The last modified time of the file.
-    def last_modified_time
-      Time.at(@j_props.lastModifiedTime.getTime() / 1000)
-    end
-
-    # @return [Boolean] Is the file a directory?
-    def directory?
-      @j_props.isDirectory
-    end
-
-    # @return [Boolean] Is the file some other file type?
-    def other?
-      @j_props.isOther
-    end
-
-    # @return [Boolean] Is it a regular file?
-    def regular_file?
-      @j_props.isRegularFile
-    end
-
-    # @return [Boolean] Is it a symbolic link?
-    def symbolic_link?
-      @j_props.isSymbolicLink
-    end
-
-    # @return [FixNum] The size of the file, in bytes.
-    def size
-      @j_props.size
-    end
-
-  end
-
-  # Represents the properties of a file system
-  # @author {http://tfox.org Tim Fox}
-  class FSProps
-
-    # @private
-    def initialize(j_props)
-      @j_props = j_props
-    end
-
-    # @return [FixNum] The total space on the file system, in bytes.
-    def total_space
-      @j_props.totalSpace
-    end
-
-    # @return [FixNum] Unallocated space on the file system, in bytes.
-    def unallocated_space
-      @j_props.unallocatedSpace
-    end
-
-    # @return [FixNum] Usable space on the file system, in bytes.
-    def usable_space
-      @j_props.usableSpace
-    end
-
-  end
-
-  # Represents a file on the file-system which can be read from, or written to asynchronously.
-  # The class also includes {ReadStream} and {WriteStream} - this allows the data to be pumped to and from
-  # other streams, e.g. an {HttpClientRequest} instance, using the {Pump} class
-  # @author {http://tfox.org Tim Fox}
-  class AsyncFile
-
-    include ReadStream, WriteStream
-
-    # @private
-    def initialize(j_file)
-      @j_del = j_file
-    end
-
-    # Close the file, asynchronously.
-    def close(&block)
-      @j_del.close(ARWrappedHandler.new(block))
-    end
-
-    # Write a {Buffer} to the file, asynchronously.
-    # When multiple writes are invoked on the same file
-    # there are no guarantees as to order in which those writes actually occur.
-    # @param [Buffer] buffer The buffer to write
-    # @param [FixNum] position The position in the file where to write the buffer. Position is measured in bytes and
-    # starts with zero at the beginning of the file.
-    def write_at_pos(buffer, position, &block)
-      @j_del.write(buffer._to_java_buffer, position, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Reads some data from a file into a buffer, asynchronously.
-    # When multiple reads are invoked on the same file
-    # there are no guarantees as to order in which those reads actually occur.
-    # @param [Buffer] buffer The buffer into which the data which is read is written.
-    # @param [FixNum] offset The position in the buffer where to start writing the data.
-    # @param [FixNum] position The position in the file where to read the data.
-    # @param [FixNum] length The number of bytes to read.
-    def read_at_pos(buffer, offset, position, length, &block)
-      @j_del.read(buffer._to_java_buffer, offset, position, length, ARWrappedHandler.new(block) { |j_buff| Buffer.new(j_buff) })
-      self
-    end
-
-    # Flush any writes made to this file to underlying persistent storage, asynchronously.
-    # If the file was opened with flush set to true then calling this method will have no effect.
-    # @param [Block] hndlr a block representing the handler which is called on completion.
-    def flush
-      Future.new(@j_del.flush)
-      self
-    end
-
-  end
- 
-
-  # Represents the file-system and contains a broad set of operations for manipulating files.
-  # An asynchronous and a synchronous version of each operation is provided.
-  # The asynchronous versions take a handler as a final argument which is
-  # called when the operation completes or an error occurs. The handler is called
-  # with two arguments; the first an exception, this will be nil if the operation has
-  # succeeded. The second is the result - this will be nil if the operation failed or
-  # there was no result to return.
-  # The synchronous versions return the results, or throw exceptions directly.
-  # @author {http://tfox.org Tim Fox}
-  class FileSystem
-
-    @@j_fs = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.fileSystem()
-
-    # Copy a file, asynchronously. The copy will fail if from does not exist, or if to already exists.
-    # @param [String] from Path of file to copy
-    # @param [String] to Path of file to copy to
-    # @param [Block] hndlr a block representing the handler which is called on completion.
-    def FileSystem.copy(from, to, &block)
-      @@j_fs.copy(from, to, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.copy}
-    def FileSystem.copy_sync(from, to)
-      @@j_fs.copySync(from, to)
-      self
-    end
-
-    # Copy a file recursively, asynchronously. The copy will fail if from does not exist, or if to already exists and is not empty.
-    # If the source is a directory all contents of the directory will be copied recursively, i.e. the entire directory
-    # tree is copied.
-    # @param [String] from Path of file to copy
-    # @param [String] to Path of file to copy to
-    def FileSystem.copy_recursive(from, to, &block)
-      @@j_fs.copy(from, to, true, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.copy_recursive}
-    def FileSystem.copy_recursive_sync(from, to)
-      @@j_fs.copySync(from, to, true)
-      self
-    end
-
-    # Move a file, asynchronously. The move will fail if from does not exist, or if to already exists.
-    # @param [String] from Path of file to move
-    # @param [String] to Path of file to move to
-    def FileSystem.move(from, to, &block)
-      @@j_fs.move(from, to, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.move}
-    def FileSystem.move_sync(from, to)
-      @@j_fs.moveSync(from, to)
-      self
-    end
-
-    # Truncate a file, asynchronously. The move will fail if path does not exist.
-    # @param [String] path Path of file to truncate
-    # @param [FixNum] len Length to truncate file to. Will fail if len < 0. If len > file size then will do nothing.
-    def FileSystem.truncate(path, len, &block)
-      @@j_fs.truncate(path, len, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.truncate}
-    def FileSystem.truncate_sync(path, len)
-      @@j_fs.truncateSync(path, len)
-      self
-    end
-
-    # Change the permissions on a file, asynchronously. If the file is directory then all contents will also have their permissions changed recursively.
-    # @param [String] path Path of file to change permissions
-    # @param [String] perms A permission string of the form rwxr-x--- as specified in
-    # {http://download.oracle.com/javase/7/docs/api/java/nio/file/attribute/PosixFilePermissions.html}. This is
-    # used to set the permissions for any regular files (not directories).
-    # @param [String] dir_perms A permission string of the form rwxr-x---. Used to set permissions for regular files.
-    def FileSystem.chmod(path, perms, dir_perms = nil, &block)
-      @@j_fs.chmod(path, perms, dir_perms, ARWrappedHandler.new(block))
-      self
-    end
-
-
-    # Synchronous version of {#FileSystem.chmod}
-    def FileSystem.chmod_sync(path, perms, dir_perms = nil)
-      @@j_fs.chmodSync(path, perms, dir_perms)
-      self
-    end
-
-    # Change the ownership of a file, asynchronously.
-    # @param [String] path Path of the file
-    # @param [String] user the user to set the ownership to
-    # @param [String] group the group to set the ownership to
-    def FileSystem.chown(path, user, group, &block)
-      @@j_fs.chown(path, user, group, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.chown}
-    def FileSystem.chown_sync(path, user, group)
-      @@j_fs.chownSync(path, user, group)
-      self
-    end
-    
-    # Get file properties for a file, asynchronously.
-    # @param [String] path Path to file
-    def FileSystem.props(path, &block)
-      @@j_fs.props(path, ARWrappedHandler.new(block) { |j_props| FileProps.new(j_props) })
-      self
-    end
-
-    # Synchronous version of {#FileSystem.props}
-    def FileSystem.props_sync(path)
-      j_props = @@j_fs.propsSync(path)
-      FileProps.new(j_props)
-    end
-
-    # Create a hard link, asynchronously..
-    # @param [String] link Path of the link to create.
-    # @param [String] existing Path of where the link points to.
-    def FileSystem.link(link, existing, &block)
-       @@j_fs.link(link, existing, ARWrappedHandler.new(block))
-       self
-    end
-
-    # Synchronous version of {#FileSystem.link}
-    def FileSystem.link_sync(link, existing)
-      @@j_fs.linkSync(link, existing)
-      self
-    end
-
-    # Create a symbolic link, asynchronously.
-    # @param [String] link Path of the link to create.
-    # @param [String] existing Path of where the link points to.
-    def FileSystem.symlink(link, existing, &block)
-       @@j_fs.symlink(link, existing, ARWrappedHandler.new(block))
-       self
-    end
-
-    # Synchronous version of {#FileSystem.symlink}
-    def FileSystem.symlink_sync(link, existing)
-      @@j_fs.symlinkSync(link, existing)
-      self
-    end
-
-    # Unlink a hard link.
-    # @param [String] link Path of the link to unlink.
-    def FileSystem.unlink(link, &block)
-      @@j_fs.unlink(link, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.unlink}
-    def FileSystem.unlinkSync(link)
-      @@j_fs.unlinkSync(link)
-      self
-    end
-
-    # Read a symbolic link, asynchronously. I.e. tells you where the symbolic link points.
-    # @param [String] link Path of the link to read.
-    def FileSystem.read_symlink(link, &block)
-      @@j_fs.readSymlink(link, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.read_symlink}
-    def FileSystem.read_symlink_sync(link)
-      @@j_fs.readSymlinkSync(link)
-    end
-
-    # Delete a file on the file system, asynchronously.
-    # The delete will fail if the file does not exist, or is a directory and is not empty.
-    # @param [String] path Path of the file to delete.
-    def FileSystem.delete(path, &block)
-      @@j_fs.delete(path, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.delete}
-    def FileSystem.delete_sync(path)
-      @@j_fs.deleteSync(path)
-      self
-    end
-
-    # Delete a file on the file system recursively, asynchronously.
-    # The delete will fail if the file does not exist. If the file is a directory the entire directory contents
-    # will be deleted recursively.
-    # @param [String] path Path of the file to delete.
-    def FileSystem.delete_recursive(path, &block)
-      @@j_fs.delete(path, true, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.delete_recursive}
-    def FileSystem.delete_recursive_sync(path)
-      @@j_fs.deleteSync(path, true)
-      self
-    end
-
-    # Create a directory, asynchronously.
-    # The create will fail if the directory already exists, or if it contains parent directories which do not already
-    # exist.
-    # @param [String] path Path of the directory to create.
-    # @param [String] perms. A permission string of the form rwxr-x--- to give directory.
-    def FileSystem.mkdir(path, perms = nil, &block)
-      @@j_fs.mkdir(path, perms, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.mkdir}
-    def FileSystem.mkdir_sync(path, perms = nil)
-      @@j_fs.mkdirSync(path, perms)
-      self
-    end
-
-    # Create a directory, and create all it's parent directories if they do not already exist, asynchronously.
-    # The create will fail if the directory already exists.
-    # @param [String] path Path of the directory to create.
-    # @param [String] perms. A permission string of the form rwxr-x--- to give the created directory(ies).
-    def FileSystem.mkdir_with_parents(path, perms = nil, &block)
-      @@j_fs.mkdir(path, perms, true, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.mkdir_with_parents}
-    def FileSystem.mkdir_with_parents_sync(path, perms = nil)
-      @@j_fs.mkdirSync(path, perms, true)
-      self
-    end
-
-    # Read a directory, i.e. list it's contents, asynchronously.
-    # The read will fail if the directory does not exist.
-    # @param [String] path Path of the directory to read.
-    # @param [String] filter A regular expression to filter out the contents of the directory. If the filter is not nil
-    # then only files which match the filter will be returned.
-    def FileSystem.read_dir(path, filter = nil, &block)
-      @@j_fs.readDir(path, filter, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.read_dir}
-    def FileSystem.read_dir_sync(path, filter = nil)
-      @@j_fs.readDirSync(path, filter)
-    end
-
-    # Read the contents of an entire file as a {Buffer}, asynchronously.
-    # @param [String] path Path of the file to read.
-    def FileSystem.read_file_as_buffer(path, &block)
-      @@j_fs.readFile(path, ARWrappedHandler.new(block) { |j_buff| Buffer.new(j_buff)})
-      self
-    end
-
-    # Synchronous version of {#FileSystem.read_file_as_buffer}
-    def FileSystem.read_file_as_buffer_sync(path)
-      @@j_fs.readFileSync(path)
-    end
-
-    # Write a [Buffer] as the entire contents of a file, asynchronously.
-    # @param [String] path Path of the file to write.
-    # @param [String] buffer The Buffer to write
-    def FileSystem.write_buffer_to_file(path, buffer, &block)
-      @@j_fs.writeFile(path, buffer, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.write_buffer_to_file}
-    def FileSystem.write_buffer_to_file_sync(path, buffer)
-      @@j_fs.writeFileSync(path, buffer)
-      self
-    end
-
-    # Open a file on the file system, asynchronously.
-    # @param [String] path Path of the file to open.
-    # @param [String] perms If the file does not exist and create_new is true, then the file will be created with these permissions.
-    # @param [Boolean] read Open the file for reading?
-    # @param [Boolean] write Open the file for writing?
-    # @param [Boolean] create_new Create the file if it doesn't already exist?
-    # @param [Boolean] flush Whenever any data is written to the file, flush all changes to permanent storage immediately?
-    def FileSystem.open(path, perms = nil, read = true, write = true, create_new = true, flush = false, &block)
-      @@j_fs.open(path, perms, read, write, create_new, flush, ARWrappedHandler.new(block){ |j_file| AsyncFile.new(j_file)})
-      self
-    end
-
-    # Synchronous version of {#FileSystem.open}
-    def FileSystem.open_sync(path, perms = nil, read = true, write = true, create_new = true, flush = false)
-      j_af = @@j_fs.open(path, perms, read, write, create_new, flush)
-      AsyncFile.new(j_af)
-    end
-
-    # Create a new empty file, asynchronously.
-    # @param [String] path Path of the file to create.
-    # @param [String] perms The file will be created with these permissions.
-    def FileSystem.create_file(path, perms = nil, &block)
-      @@j_fs.createFile(path, perms, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.create_file}
-    def FileSystem.create_file_sync(path, perms = nil)
-      @@j_fs.createFileSync(path, perms)
-      self
-    end
-
-    # Check if  a file exists, asynchronously.
-    # @param [String] path Path of the file to check.
-    def FileSystem.exists?(path, &block)
-      @@j_fs.exists(path, ARWrappedHandler.new(block))
-      self
-    end
-
-    # Synchronous version of {#FileSystem.exists?}
-    def FileSystem.exists_sync?(path)
-      @@j_fs.existsSync(path)
-    end
-
-    # Get properties for the file system, asynchronously.
-    # @param [String] path Path in the file system.
-    def FileSystem.fs_props(path, &block)
-      @@j_fs.fsProps(path, ARWrappedHandler.new(block) { |j_props| FSProps.new(j_props)})
-      self
-    end
-
-    # Synchronous version of {#FileSystem.fs_props}
-    def FileSystem.fs_props_sync(path)
-      j_fsprops = @@j_fs.fsPropsSync(path)
-      FSProps.new(j_fsprops)
-    end
-
-  end
-end