coronet 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Coronet.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/Coronet/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Joseph Weissman"]
+  gem.email         = ["jweissman1986@gmail.com"]
+  gem.description   = %q{Coronet is a simple protocol adaption framework}
+  gem.summary       = %q{Coronet is an extensible message-mediation server appliance.}
+  # gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  # gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "coronet"
+  gem.require_paths = ["lib"]
+  gem.version       = Coronet::VERSION
+end

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Coronet.gemspec
+# gemspec
+gem 'rspec'
+gem 'contractual'
+
+# formats...
+gem 'xml-simple'
+gem 'psych'
+
+# rspec syntax
+gem 'syntax'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,106 @@
+# Coronet
+
+Coronet is a dynamically-reconfigurable message-mediation (transformation) server appliance.
+
+(A 'coronet' is a small, simple crown -- possibly made with grass or leaves.)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'coronet'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install coronet
+
+## Usage
+
+Coronet requires the definition of message formats, transports, service entry/end-points and mediation rules. Once these are defined, you can construct 'service layers' which automatically mediate messages.
+
+### Message Formats
+
+*Message formats* currently just have to implement 'pack' and 'unpack' functions.
+
+Currently provided are a simple Yaml and XML message format specification.
+
+Eventually there should be mappers which can transform hash keys.
+
+	class MyCustomMessageFormat < Coronet::MessageFormat
+		def pack(hash)
+			# pack logic goes here
+			# return binary data/string/whatever
+		end
+	
+		def unpack(data)
+			# unpack business logic
+			# return hash of element names => values
+		end
+	end
+
+
+### Transformation Rules
+
+*Transformation rules* adapt one message format to another. Eventually this may support
+manipulation/mapping of key names.
+
+### Transport Mechanisms
+
+*Transport mechanisms* encapsulate functional requirements for message transport to 
+remote services.
+
+Currently, transport mechanisms have to implement 'open', 'read', 'write(data)' 
+and 'close' methods. There is a simple length-prefixed TCP implementation provided.
+I'd like to eventually support SSL (over TCP) and HTTP(S).
+
+### Protocols
+
+A *protocol* combines a particular transport mechanism and a message format. 
+
+### Listeners, Remote Endpoints and Mediators
+
+*Listeners* are entrypoints into the mediating framework, and need to specify
+their message format, transport mechanism, and local listening port.
+
+*Remote endpoints* are foreign service interfaces, which need to specify
+the format and transport like a listener, but also need to specify the remote
+address and port of the target host.
+
+*Mediators* link these together into a concrete process resulting in requests 
+being transformed, transported to remote endpoints, the responses gathered, 
+transformation rules applied, and the initiating actor (client) being sent 
+the transformed response.
+
+## Example
+
+The following simple example should start the Coronet engine on localhost:10000,
+listening for XML requests via TCP, and mediate the requests to localhost:10001
+in YML over TCP.
+
+	require 'coronet'
+	
+	tcp = Coronet::TransportMechanism::LengthPrefixedTcpTransport.new
+	xml = Coronet::MessageFormat::XmlMessageFormat.new
+	yml = Coronet::MessageFormat::YamlMessageFormat.new
+
+	mediator = Coronet::Mediator.new do
+	  local  xml, tcp, 10000
+	  remote yml, tcp, 'localhost', 10001        
+	end
+
+	mediator.start
+
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/Coronet/version.rb

@@ -0,0 +1,3 @@
+module Coronet
+  VERSION = "0.0.1"
+end

data/lib/coronet/listener.rb

@@ -0,0 +1,25 @@
+module Coronet
+  class Listener < GServer
+    attr_accessor :port
+    attr_accessor :protocol
+    attr_accessor :callback
+    
+    def initialize(port, protocol, callback=nil)
+      @port     = port
+      @protocol = protocol
+      @callback = callback
+      
+      # start listening on port
+      super(port)
+    end
+    
+    def serve(io)
+      request = @protocol.read(io)
+      puts "--- listener invoking callback with request: #{request}"
+      response = callback.call(request)
+      puts "--- listener got response: #{response}"
+      @protocol.write(response, io)
+      # io.close
+    end
+  end
+end

data/lib/coronet/mediator.rb

@@ -0,0 +1,44 @@
+module Coronet
+  class Mediator
+    attr_accessor :listener, :remote_endpoint
+    
+    def initialize(opts={}, &block) 
+      with_listener(opts[:listener])  if opts.has_key? :listener
+      using_endpoint(opts[:endpoint]) if opts.has_key? :endpoint
+      
+      instance_eval &block if block_given?
+    end
+    
+    def with_listener(listener)
+      @listener = listener
+      @listener.callback = method(:handle)
+      self
+    end
+    
+    def using_endpoint(remote_endpoint)
+      @remote_endpoint = remote_endpoint
+      self
+    end
+    
+    def local(message_format, transport_mechanism, port)
+      protocol = Protocol.new(message_format, transport_mechanism)
+      listener = Listener.new(port, protocol)
+      with_listener(listener)
+    end
+    
+    def remote(message_format, transport_mechanism, remote_host, remote_port)
+      protocol = Protocol.new(message_format, transport_mechanism)
+      endpoint = RemoteEndpoint.new(remote_host, remote_port, protocol)
+      using_endpoint(endpoint)
+    end
+
+    # proxy start/stop to listener
+    def start; @listener.start; end
+    def stop; @listener.stop;   end
+    
+    def handle(request)
+      @remote_endpoint.transmit(request)
+    end
+    
+  end
+end

data/lib/coronet/message_format/base.rb

@@ -0,0 +1,17 @@
+module Coronet
+  module MessageFormat
+    class Base
+    
+      include Contractual::Interface
+    
+      must :pack, :message
+      must :unpack, :message
+    
+      def transform(message, outgoing_format)
+        unpacked = unpack(message)
+        outgoing_format.pack(unpacked)
+      end
+    
+    end
+  end
+end

data/lib/coronet/message_format/xml_message_format.rb

@@ -0,0 +1,15 @@
+module Coronet
+  module MessageFormat
+    class XmlMessageFormat < Base
+      # transform xml string to hash
+      def unpack(xml_str)
+        XmlSimple.xml_in(xml_str, forcearray: false, keeproot: true)
+      end
+      
+      # transform hash to xml string
+      def pack(hash)
+        XmlSimple.xml_out(hash, noattr: true, rootname: nil).strip!
+      end
+    end
+  end
+end

data/lib/coronet/message_format/yaml_message_format.rb

@@ -0,0 +1,18 @@
+module Coronet
+  module MessageFormat
+    class YamlMessageFormat < Base
+      
+      # transform yml string to hash
+      def unpack(yml_str)
+        Psych.load(yml_str)
+        # YAML.load(yml_str)
+      end
+      
+      # transform hash to yml string
+      def pack(hash)
+        yml_out = Psych.dump(hash) #.strip!
+      end
+      
+    end
+  end
+end

data/lib/coronet/protocol.rb

@@ -0,0 +1,30 @@
+module Coronet
+  class Protocol
+    attr_accessor :message_format
+    attr_accessor :transport_mechanism
+    
+    def initialize(message_format, transport_mechanism)
+      @message_format        = message_format
+      @transport_mechanism   = transport_mechanism
+    end
+    
+    def read(io)
+      packed = @transport_mechanism.read(io)
+      unpacked = @message_format.unpack(packed)
+      unpacked
+    end
+    
+    def write(data, io)
+      packed = @message_format.pack(data)
+      @transport_mechanism.write(packed, io)
+    end
+    
+    def transmit(request, host, port)
+      io = @transport_mechanism.open(host,port)
+      write(request, io)
+      response = read(io)
+      @transport_mechanism.close(io)
+      response
+    end
+  end
+end

data/lib/coronet/remote_endpoint.rb

@@ -0,0 +1,16 @@
+module Coronet
+  class RemoteEndpoint
+    attr_accessor :host, :port
+    attr_accessor :protocol
+    
+    def initialize(host, port, protocol)
+      @host = host
+      @port = port
+      @protocol = protocol
+    end
+    
+    def transmit(request)
+      @protocol.transmit(request, @host, @port)
+    end
+  end
+end

data/lib/coronet/support/echo_server.rb

@@ -0,0 +1,15 @@
+module Coronet
+  module Support
+    
+    class EchoServer < GServer
+      def initialize(port=12345, *args)
+        super(port, *args)
+        @tcp = TransportMechanism::LengthPrefixedTcpTransport.new
+      end
+      def serve(io)
+        @tcp.write(@tcp.read(io), io)
+      end
+    end
+
+  end
+end

data/lib/coronet/transformation_rule.rb

@@ -0,0 +1,16 @@
+module Coronet
+  class TransformationRule
+    attr_accessor :in, :out
+    
+    def initialize(incoming, outgoing)
+      @in = incoming
+      @out = outgoing
+    end
+    
+    def apply(message)
+      @in.transform(message, @out)
+    end
+    
+    def inverse; TransformationRule.new(@out, @in); end
+  end
+end

data/lib/coronet/transport_mechanism/base.rb

@@ -0,0 +1,29 @@
+module Coronet
+  module TransportMechanism
+    class Base
+      include Contractual::Interface
+    
+      must :open, :host, :port
+      must :write, :data
+      must :read
+      must :close
+      
+      # attr_accessor :host, :port
+      # attr_accessor :io
+      
+      # def initialize #(host, port)
+        # @host = host
+        # @port = port
+      # end
+    
+      def transmit(data, io)
+        # io = open(host, port)
+        write(data, io)
+        response = read(io)
+        close(io)
+        
+        response
+      end
+    end
+  end
+end

data/lib/coronet/transport_mechanism/length_prefixed_tcp_transport.rb

@@ -0,0 +1,46 @@
+module Coronet
+  module TransportMechanism
+    #
+    #
+    #  Supports length-prefixed TCP transport.
+    #
+    #
+    class LengthPrefixedTcpTransport < Base
+      attr_accessor :tcp_socket
+      
+      def open(host, port)
+        TCPSocket.open(host, port)
+      end
+      
+      def read(io)
+        length_header = io.read(2)
+        p length_header
+        length = length_header.unpack("S").first
+        io.read(length)
+      end
+      
+      def write(data, io)
+        length = data.size
+        prefix = to_byte_array(length).pack("S")
+
+        io.print(prefix)
+        io.print(data)
+      end
+      
+      def close(io)
+        io.close
+      end
+      
+      private 
+        def to_byte_array(num)
+          result = Array.new
+          begin
+            result << (num & 0xff)
+            num >>= 8
+          end until (num == 0 || num == -1) && (result.last[7] == num[7])
+          result.reverse
+        end
+      
+    end
+  end
+end

data/lib/coronet.rb

@@ -0,0 +1,5 @@
+require "Coronet/version"
+
+module Coronet
+  # Your code goes here...
+end

data/spec/coronet/listener.spec

@@ -0,0 +1,40 @@
+require 'gserver'
+
+require 'contractual'
+require 'xmlsimple'
+
+require 'coronet/message_format/base'
+require 'coronet/message_format/xml_message_format'
+
+require 'coronet/transport_mechanism/base'
+require 'coronet/transport_mechanism/length_prefixed_tcp_transport'
+
+require 'coronet/protocol'
+require 'coronet/listener'
+
+module Coronet
+  describe Listener, "encapsulates an entrypoint into the mediating framework" do
+    
+    module Echo
+      def self.handle(request)
+        # puts "--- echo server handling request: #{request}"
+        request
+      end
+    end
+    
+    it "serves external requests and provides a callback for processing" do
+      
+      tcp = TransportMechanism::LengthPrefixedTcpTransport.new
+      xml = MessageFormat::XmlMessageFormat.new
+      xml_via_tcp = Protocol.new(xml, tcp)
+      
+      echo_listener = Listener.new(12345, xml_via_tcp, Echo.method(:handle))
+      echo_listener.start
+      
+      msg = { 'hello' => 'world' }
+      xml_via_tcp.transmit(msg, 'localhost', 12345).should == msg
+      
+      echo_listener.stop
+    end
+  end
+end

data/spec/coronet/mediator.spec

@@ -0,0 +1,81 @@
+require 'gserver'
+
+require 'contractual'
+require 'xmlsimple'
+
+require 'coronet/support/echo_server'
+
+require 'coronet/message_format/base'
+require 'coronet/message_format/xml_message_format'
+require 'coronet/message_format/yaml_message_format'
+
+require 'coronet/transport_mechanism/base'
+require 'coronet/transport_mechanism/length_prefixed_tcp_transport'
+
+require 'coronet/protocol'
+require 'coronet/listener'
+require 'coronet/transformation_rule'
+require 'coronet/remote_endpoint'
+
+require 'coronet/mediator'
+
+module Coronet
+  
+  describe Mediator, "mediates between clients and servers" do
+    # it "mediates between client and server"
+    # it "transforms message formats"
+    it "adapts transport mechanisms and protocols" do
+      tcp = TransportMechanism::LengthPrefixedTcpTransport.new
+      
+      xml = MessageFormat::XmlMessageFormat.new
+      yml = MessageFormat::YamlMessageFormat.new
+      
+      xml_via_tcp = Protocol.new(xml, tcp)
+      yml_via_tcp = Protocol.new(yml, tcp)
+      
+      xml_to_yml = TransformationRule.new(xml, yml)
+      
+      listener = Listener.new(10000, xml_via_tcp)
+      
+      echo_server = Support::EchoServer.new(10001)
+      echo_server_endpoint = RemoteEndpoint.new('localhost', 10001, yml_via_tcp)
+      
+      mediator = Mediator.new listener: listener, endpoint: echo_server_endpoint # , xml_to_yml)
+      
+      echo_server.start
+      mediator.start
+      
+      msg = { 'hello' => 'world' }
+      xml_via_tcp.transmit(msg, 'localhost', 10000).should == msg
+      
+      mediator.stop
+      echo_server.stop
+    end
+    
+    it "supports a basic DSL" do
+      
+      tcp = TransportMechanism::LengthPrefixedTcpTransport.new
+      xml = MessageFormat::XmlMessageFormat.new
+      yml = MessageFormat::YamlMessageFormat.new
+      
+      mediator = Mediator.new do
+        local  xml, tcp, 10000
+        remote yml, tcp, 'localhost', 10001        
+      end
+      
+      echo_server = Support::EchoServer.new(10001)
+      
+      msg = { 'hello' => 'world' }
+      xml_via_tcp = Protocol.new(xml, tcp)
+      
+      mediator.start
+      echo_server.start
+      
+      xml_via_tcp.transmit(msg, 'localhost', 10000).should == msg
+      
+      echo_server.stop
+      mediator.stop
+      
+    end
+  end
+end

data/spec/coronet/message_format/base.spec

@@ -0,0 +1,35 @@
+require 'contractual'
+require 'xmlsimple'
+
+require 'coronet/message_format/base'
+require 'coronet/message_format/xml_message_format'
+require 'coronet/message_format/yaml_message_format'
+
+module Coronet
+  module MessageFormat
+    describe Base, "should describe structured message formats" do
+    
+      before :each do
+        @yml, @xml = YamlMessageFormat.new, XmlMessageFormat.new
+        @yml_data = "---\nhello: world\n"
+        @xml_data = "<hello>world</hello>"
+      end
+    
+      it "should handle yml" do
+        @yml.unpack(@yml_data).should == { 'hello' => 'world' }
+        @yml.pack(@yml.unpack(@yml_data)).should == @yml_data
+      end
+    
+      it "should handle xml" do
+        @xml.unpack(@xml_data).should == { 'hello' => 'world' }
+        @xml.pack(@xml.unpack(@xml_data)).should == @xml_data
+      end
+
+      it "should handle transforming yml to xml (and vice versa)" do
+        @xml.unpack(@xml_data).should == @yml.unpack(@yml_data)
+        @xml.pack(@yml.unpack(@yml_data)).should == @xml_data
+        @yml.pack(@xml.unpack(@xml_data)).should == @yml_data
+      end
+    end
+  end
+end

data/spec/coronet/protocol.spec

@@ -0,0 +1,31 @@
+require 'gserver'
+
+require 'contractual'
+require 'xmlsimple'
+
+require 'coronet/message_format/base'
+require 'coronet/message_format/xml_message_format'
+
+require 'coronet/transport_mechanism/base'
+require 'coronet/transport_mechanism/length_prefixed_tcp_transport'
+require 'coronet/support/echo_server'
+
+require 'coronet/protocol'
+
+module Coronet
+  describe Protocol, "conjoins a message format and transport-layer functionality" do
+    it "supports xml-via-tcp interaction with remote interfaces" do 
+      echo = Support::EchoServer.new
+      echo.start
+      
+      tcp = TransportMechanism::LengthPrefixedTcpTransport.new
+      xml = MessageFormat::XmlMessageFormat.new
+      xml_via_tcp = Protocol.new(xml, tcp)
+      
+      msg = { 'hello' => 'world' }
+      xml_via_tcp.transmit(msg, 'localhost', 12345).should == msg
+      
+      echo.stop
+    end
+  end
+end

data/spec/coronet/remote_endpoint.spec

@@ -0,0 +1,36 @@
+require 'gserver'
+
+require 'contractual'
+require 'xmlsimple'
+
+require 'coronet/message_format/base'
+require 'coronet/message_format/xml_message_format'
+
+require 'coronet/transport_mechanism/base'
+require 'coronet/transport_mechanism/length_prefixed_tcp_transport'
+
+require 'coronet/protocol'
+require 'coronet/remote_endpoint'
+
+require 'coronet/support/echo_server'
+
+module Coronet
+  
+  describe RemoteEndpoint, "conjoins a concrete endpoint, message format and transport-layer functionality" do
+    it "supports xml-via-tcp interaction with remote interfaces" do
+      
+      tcp = TransportMechanism::LengthPrefixedTcpTransport.new
+      xml = MessageFormat::XmlMessageFormat.new
+      xml_via_tcp = Protocol.new(xml, tcp)
+      echo_server_endpoint = RemoteEndpoint.new('localhost', 12345, xml_via_tcp)
+      
+      msg = { 'hello' => 'world' }
+      
+      echo = Support::EchoServer.new
+      echo.start
+      echo_server_endpoint.transmit(msg).should == msg
+      echo.stop
+    end
+  end
+  
+end

data/spec/coronet/transformation_rule.spec

@@ -0,0 +1,29 @@
+require 'contractual'
+require 'xmlsimple'
+require 'psych'
+
+require 'coronet/message_format/base'
+require 'coronet/message_format/xml_message_format'
+require 'coronet/message_format/yaml_message_format'
+
+require 'coronet/transformation_rule'
+
+module Coronet
+  describe TransformationRule, "transforms messages into other formats" do
+    before :each do
+      @yml, @xml = MessageFormat::YamlMessageFormat.new, MessageFormat::XmlMessageFormat.new
+      @yml_data = "---\nhello: world\n"
+      @xml_data = "<hello>world</hello>"
+    end
+    
+    it "transforms xml to yml" do
+      rule = TransformationRule.new(@xml, @yml)
+      rule.apply(@xml_data).should == @yml_data
+    end
+    
+    it "transforms yml to xml" do
+      rule = TransformationRule.new(@yml, @xml)
+      rule.apply(@yml_data).should == @xml_data
+    end    
+  end
+end

data/spec/coronet/transport_mechanism/base.spec

@@ -0,0 +1,24 @@
+require 'gserver'
+
+require 'contractual'
+
+require 'coronet/transport_mechanism/base'
+require 'coronet/transport_mechanism/length_prefixed_tcp_transport'
+
+require 'coronet/support/echo_server'
+
+module Coronet
+  module TransportMechanism
+    describe Base, "encapsulates transport-layer functionality" do
+      it "supports interaction with remote services" do
+        echo = Support::EchoServer.new(12345)
+        tcp  = LengthPrefixedTcpTransport.new# ('localhost', 12345)
+        
+        echo.start
+        io   = tcp.open('localhost', 12345)
+        tcp.transmit("hello", io).should == 'hello'
+        echo.stop
+      end   
+    end
+  end
+end

data/spec/coronet_spec.rb

@@ -0,0 +1 @@
+require 'coronet'

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: coronet
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joseph Weissman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-26 00:00:00.000000000 Z
+dependencies: []
+description: Coronet is a simple protocol adaption framework
+email:
+- jweissman1986@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Coronet.gemspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/Coronet/version.rb
+- lib/coronet.rb
+- lib/coronet/listener.rb
+- lib/coronet/mediator.rb
+- lib/coronet/message_format/base.rb
+- lib/coronet/message_format/xml_message_format.rb
+- lib/coronet/message_format/yaml_message_format.rb
+- lib/coronet/protocol.rb
+- lib/coronet/remote_endpoint.rb
+- lib/coronet/support/echo_server.rb
+- lib/coronet/transformation_rule.rb
+- lib/coronet/transport_mechanism/base.rb
+- lib/coronet/transport_mechanism/length_prefixed_tcp_transport.rb
+- spec/coronet/listener.spec
+- spec/coronet/mediator.spec
+- spec/coronet/message_format/base.spec
+- spec/coronet/protocol.spec
+- spec/coronet/remote_endpoint.spec
+- spec/coronet/transformation_rule.spec
+- spec/coronet/transport_mechanism/base.spec
+- spec/coronet_spec.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Coronet is an extensible message-mediation server appliance.
+test_files: []