bitgirder-platform 0.1.7 → 0.1.10

data/bin/install-mysql

@@ -176,14 +176,18 @@ class App < BitGirderClass
 
     private
     def update_root_accounts( db )
- 
-        sql = <<-SQL
-            update mysql.user 
-            set password = password( '#{db.escape_string( root_pass() )}' )
-            where user = 'root'
-        SQL
 
-        db.query( sql )
+        ru = db.escape_string( root_user )
+        rp = db.escape_string( root_pass )
+
+        db.query( "delete from mysql.user where user = 'root'" )
+        db.query( "flush privileges" )
+
+        db.query <<-SQL
+            grant all on *.* to '#{ru}'@'localhost' identified by '#{rp}' 
+            with grant option
+        SQL
+ 
         db.query( "flush privileges" )
     end
 
@@ -224,15 +228,16 @@ class App < BitGirderClass
         set_root_pass( opts )
 
         # Now re-connect with pass (to verify that previous step worked)
-        opts.merge!( password: root_pass() )
+        opts.merge!( user: root_user(), password: root_pass() )
         secure_db_install( opts )
     end
 
     private
-    def stop_db( pid, with_pass )
+    def stop_db( pid, with_defaults )
         
-        argv = [ "--defaults-file=#{my_cnf()}", "-u", "root" ]
-        argv << "--password=#{root_pass()}" if with_pass
+        u = with_defaults ? "root" : root_user
+        argv = [ "--defaults-file=#{my_cnf()}", "-u", "#{u}" ]
+        argv << "--password=#{root_pass()}" unless with_defaults
         argv << "shutdown" 
 
         UnixProcessBuilder.new( cmd: mysqladmin(), argv: argv ).system
@@ -252,7 +257,7 @@ class App < BitGirderClass
             run_db_init
             init_done = true
         ensure
-            stop_db( pid, init_done )
+            stop_db( pid, ! init_done )
         end
     end
 
@@ -293,7 +298,11 @@ class App < BitGirderClass
             io.print <<-END
 #!#{bash()}
 
-exec #{mysqladmin()} --defaults-file=#{my_cnf()} -u #{root_user()} "$@"
+exec #{mysqladmin()} \
+    --defaults-file=#{my_cnf()} \
+    -u #{root_user()} \
+    -p#{root_pass()} \
+    "$@"
             END
         end
     end

data/bin/tomcat7

@@ -8,75 +8,27 @@ require 'bitgirder/io'
 require 'bitgirder/ops/java'
 include BitGirder::Ops::Java
 
-require 'mingle'
-include Mingle
-
-require 'mingle/json'
-
 require 'rexml/document'
 
 require 'socket'
 
-ENV_TOMCAT7_HOME = "TOMCAT7_HOME"
+ENV_TOMCAT7_RUNTIME = "TOMCAT7_RUNTIME"
 
 class Command < BitGirderClass
 
     include BitGirder::Io
 
-    private
-    def load_struct( f )
-
-        File.open( f ) do |io|
-            Mingle::Json::JsonMingleCodec.new.from_buffer( io.read( io.size ) )
-        end
-    end
-
-    private
-    def save_struct( f, s )
-        
-        File.open( ensure_parent( f ), "w" ) do |io|
-            io.print Mingle::Json::JsonMingleCodec.new.as_buffer( s )
-        end
-    end
-
     private
     def load_config( f )
-        
-        flds = load_struct( f ).fields
-
-        TomcatConfig.new(
-            control_port: flds.expect_int( :control_port ),
-            http_port: flds.expect_int( :http_port ),
-            https_port: flds.expect_int( :https_port ),
-            shutdown_string: flds.expect_string( :shutdown_string ),
-            tomcat_home: flds.expect_string( :tomcat_home ),
-            java_home: flds.expect_string( :java_home )
-        )
-    end
-
-    private
-    def load_runtime_config( rt )
-        load_config( "#{rt}/config.json" )
-    end
-end
-
-class Help < Command
-
-    public
-    def run( run_ctx )
- 
-        print "\ncommands:\n\n"
-        COMMANDS.keys.sort.each { |s| puts "#{ " " * 4 }#{s}" }
-        puts
-
+        load_yaml( f )
     end
 end
 
 class TomcatConfig < BitGirderClass
     
     bg_attr :control_port, validation: :positive
-    bg_attr :http_port, validation: :positive
-    bg_attr :https_port, validation: :positive
+    bg_attr :http_port, validation: :positive, required: false
+    bg_attr :https_port, validation: :positive, required: false
 
     bg_attr :shutdown_string
     
@@ -86,67 +38,29 @@ class TomcatConfig < BitGirderClass
             validation: :file_exists,
             default: lambda { JavaEnvironments.get_java_home }
     
-    public
-    def to_mingle_struct
-        
-        MingleStruct.new(
-            type: :"bitgirder:ops:tomcat@v1/TomcatConfig",
-            fields: {
-                control_port: @control_port,
-                http_port: @http_port,
-                https_port: @https_port,
-                shutdown_string: @shutdown_string,
-                tomcat_home: @tomcat_home,
-                java_home: @java_home
-            }
-        )
-    end
+    bg_attr :sysprops, default: lambda { {} }
+
+    bg_attr :classpath_dirs, default: lambda { [] }
 end
 
 PORT_OPTS = { validation: :positive, processor: :integer }
 
+def tomcat7_dir( base )
+    "#{base}/tomcat7"
+end
+
 class Install < Command
 
     PROTO_HTTP11 = "HTTP/1.1"
 
     bg_attr :install_to
 
+    bg_attr :install_opts, validation: :file_exists
+ 
     bg_attr :tomcat_home, validation: :file_exists
 
-    bg_attr :control_port, PORT_OPTS
-
-    bg_attr :http_port, PORT_OPTS
-
-    bg_attr :https_port, PORT_OPTS.merge( required: false )
-
-    bg_attr :ssl_keystore, validation: :file_exists, required: false
-
-    bg_attr :ssl_keystore_pass, required: false
-
-    bg_attr :ssl_keystore_type, required: false
-
-    bg_attr :ssl_key_alias, required: false
-
-    bg_attr :ssl_key_pass, required: false
-
     bg_attr :wipe_install, required: false, processor: :boolean
 
-    bg_attr :webapps,
-            is_list: true,
-            processor: lambda { |s|
-                idx = s.index( "=" ) || s.size
-                dest = s[ 0, idx ]
-                if idx < s.size - 1
-                    [ dest, s[ idx + 1 .. -1 ] ]
-                else
-                    raise "Need a name for webapp #{dest}"
-                end
-            },
-            list_validation: :not_empty
-
-    bg_attr :java_home,
-            default: lambda { JavaEnvironments.get_java_home }
-
     private
     def impl_initialize
         
@@ -161,20 +75,50 @@ class Install < Command
 
     private
     def base_dir( dir )
-        "#@install_to/catalina/#{dir}"
+        "#{tomcat7_dir( @install_to )}/#{dir}"
     end
 
+    # Scoped to its own method to reduce risk of local vars in eval'd code
+    # stomping on something in this script
     private
-    def init_config
+    def eval_install_opts
+        eval( IO::read( @install_opts ), binding, @install_opts )
+    end
 
-        @config = TomcatConfig.new(
-            control_port: @control_port,
-            http_port: @http_port,
-            https_port: @https_port,
+    private
+    def load_install_opts
+        
+        case @install_opts
+        when /\.rb$/ then eval_install_opts
+        when /\.yaml$/ then load_yaml( @install_opts )
+        else raise "Unhandled install opts: #@install_opts"
+        end
+    end
+
+    private
+    def expect_install_opt( opts, key )
+        
+        opts[ key ] or raise "No value in install opts for #{key.inspect}"
+    end
+
+    private
+    def init_config( tc_opts )
+
+        defls = { 
             shutdown_string: rand( 2 ** 128 ).to_s( 16 ),
-            tomcat_home: @tomcat_home,
-            java_home: @java_home
-        )
+            tomcat_home: @tomcat_home
+        }
+
+        @config = TomcatConfig.new( defls.merge( tc_opts ) )
+    end
+
+    private
+    def process_install_opts
+
+        opts = load_install_opts
+        init_config( expect_install_opt( opts, :tomcat_opts ) )
+        @webapps = expect_install_opt( opts, :webapps )
+        @ssl_opts = opts[ :ssl_opts ] || {}
     end
 
     private
@@ -232,7 +176,7 @@ class Install < Command
     private
     def add_https_connector( svc )
         
-        svc << new_elt( :Connector,
+        attrs = {
             :port => @config.https_port,
             :protocol => PROTO_HTTP11,
             :SSLEnabled => true,
@@ -240,13 +184,12 @@ class Install < Command
             :scheme => "https",
             :secure => true,
             :clientAuth => false,
-            :sslProtocol => :TLS,
-            :keystoreFile => @ssl_keystore,
-            :keystorePass => @ssl_keystore_pass,
-            :keystoreType => @ssl_keystore_type,
-            :keyAlias => @ssl_key_alias,
-            :keyPass => @ssl_key_pass
-        )
+            :sslProtocol => :TLS
+        }
+
+        attrs.merge!( @ssl_opts )
+
+        svc << new_elt( :Connector, attrs )
     end
 
     private
@@ -279,8 +222,8 @@ class Install < Command
  
         doc.root << ( svc = new_elt( :Service, :name => "Catalina" ) )
 
-        add_http_connector( svc )
-        add_https_connector( svc )
+        add_http_connector( svc ) if @config.http_port
+        add_https_connector( svc ) if @config.https_port
 
         add_engine( svc )
     end
@@ -317,7 +260,7 @@ class Install < Command
     def install_webapps
        
         @webapps.each do |app|
-            
+ 
             dest, src = *app
             dest = ensure_parent( dest )
             fu().ln_s( src, "#{base_dir( :webapps )}/#{dest}" )
@@ -326,23 +269,41 @@ class Install < Command
 
     private
     def write_config
-        save_struct( "#@install_to/config.json", @config.to_mingle_struct )
+        dump_yaml( @config, "#@install_to/config.yaml" )
+    end
+
+    private
+    def write_logging_properties
+        
+        File.open( "#{base_dir( :conf )}/logging.properties", "w" ) do |io|
+
+            io.print <<-END_LOGGING
+handlers = java.util.logging.ConsoleHandler
+.handlers = java.util.logging.ConsoleHandler
+java.util.logging.ConsoleHandler.level = FINE
+java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
+org.apache.catalina.core.ContainerBase.[Catalina].[localhost].level = INFO
+org.apache.catalina.core.ContainerBase.[Catalina].[localhost].handlers = java.util.logging.ConsoleHandler
+            END_LOGGING
+        end
     end
 
     public
     def run
  
-        init_config
+        process_install_opts
         setup_install_dir
         write_server_conf
         install_webapps
         write_config
+        write_logging_properties
     end
 end
 
 class TomcatProcessBuilder < BitGirderClass
     
     bg_attr :runtime
+
     bg_attr :config
 
     bg_attr :proc_opts, default: lambda { {} }
@@ -351,30 +312,42 @@ class TomcatProcessBuilder < BitGirderClass
 
     private
     def get_run_classpath
-        
-        %w{ bootstrap.jar tomcat-juli.jar }.map do |f|
+ 
+        res = %w{ bootstrap.jar tomcat-juli.jar }.map do |f|
             file_exists( "#{@config.tomcat_home}/bin/#{f}" )
         end
+
+        res += @config.classpath_dirs
+
+        res
+    end
+
+    private
+    def get_config_sysprops
+        {}
     end
 
     private
     def get_run_sysprops
  
         cat_home = @config.tomcat_home
+        cat_base = tomcat7_dir( @runtime )
 
         res = {
 
             "java.util.logging.config.file" =>
-                file_exists( "#{cat_home}/conf/logging.properties" ),
+                file_exists( "#{cat_base}/conf/logging.properties" ),
 
             "java.util.logging.manager" =>
                 "org.apache.juli.ClassLoaderLogManager",
  
-            "catalina.base" => "#@runtime/catalina",
+            "catalina.base" => cat_base,
             "catalina.home" => cat_home,
 
-            "java.io.tmpdir" => file_exists( "#@runtime/catalina/temp" )
+            "java.io.tmpdir" => file_exists( "#{cat_base}/temp" )
         }
+
+        res.merge( @config.sysprops )
     end
 
     private
@@ -402,13 +375,21 @@ class RuntimeCommand < Command
     
     bg_attr :runtime, 
             validation: :file_exists,
-            default: ENV[ ENV_TOMCAT7_HOME ]
+            processor: :expand_path,
+            required: true, # Since our default may still return nil
+            default: lambda {
+                if ( v = ( ENV[ ENV_TOMCAT7_RUNTIME ] || "" ).strip ).empty?
+                    nil
+                else   
+                    v
+                end
+            }
     
     include BitGirder::Io
 
     private
     def impl_initialize
-        @config = load_config( file_exists( "#@runtime/config.json" ) )
+        @config = load_config( file_exists( "#@runtime/config.yaml" ) )
     end
 
     private
@@ -432,19 +413,52 @@ end
 class Daemon < RuntimeCommand
 
     private
-    def do_start
- 
-        b = TomcatProcessBuilder.new( config: @config, runtime: @runtime )
+    def exec_daemon( b )
 
         Process.daemon
+
         File.open( pid_file, "w" ) { |io| io.puts $$ }
         
-        out = "#@runtime/catalina/logs/catalina.out"
+        out = "#{tomcat7_dir( @runtime )}/logs/catalina.out"
+        code( "Sending daemon output to #{out}" )
         b.proc_opts[ [ STDOUT, STDERR ] ] = File.open( out, "a" )
 
         b.build.exec
     end
 
+    private
+    def await_start
+        
+        connected = 4.times.find do |i|
+            begin
+                TCPSocket::new( "localhost", @config.control_port ).close
+                true
+            rescue Errno::ECONNREFUSED
+                code( "Server ctl port not up yet; waiting" )
+                sleep( 2 ** i )
+                false
+            end
+        end 
+
+        raise "Could not get a ctl port connection" unless connected
+    end
+
+    private
+    def do_start
+ 
+        b = TomcatProcessBuilder.new( config: @config, runtime: @runtime )
+
+        if File.exist?( pid_file )
+            raise "Tomcat already running (or stale pid file #{pid_file})"
+        end
+
+        if fork
+            await_start
+        else
+            exec_daemon( b )
+        end
+    end
+
     private
     def get_current_pid
         
@@ -490,9 +504,13 @@ class Daemon < RuntimeCommand
     private
     def await_srv_close
         
+        to_check = [ @config.control_port ]
+        to_check << @config.http_port if @config.http_port
+        to_check << @config.https_port if @config.https_port
+        
         # Returns true if and only if all ports are seen closed
-        ! [ :control_port, :http_port, :https_port ].find do |port|
-            ! await_port_close( @config.send( port ) )
+        ! to_check.find do |port|
+            ! await_port_close( port )
         end
     end
 
@@ -517,13 +535,20 @@ class Daemon < RuntimeCommand
         do_stop
         do_start
     end
+
+    private
+    def do_wipe_pid
+        
+        fu().rm( pid_file ) if File.exist?( pid_file )
+    end
  
     public
     def run( run_ctx )
  
         cmd = run_ctx[ :argv_remain ].shift or raise "Need a daemon command"
+        meth = :"do_#{cmd.gsub( "-", "_" )}"
 
-        if respond_to?( meth = :"do_#{cmd}", true )
+        if respond_to?( meth, true )
             send( meth )
         else
             raise "Unknown daemon command: #{cmd}"
@@ -538,7 +563,7 @@ class Tailf < RuntimeCommand
         
         UnixProcessBuilder.new(
             cmd: "tail",
-            argv: [ "-f" ] + Dir.glob( "#@runtime/catalina/logs/*" )
+            argv: [ "-f" ] + Dir.glob( "#{tomcat7_dir( @runtime )}/logs/*" )
         ).
         exec
     end
@@ -548,22 +573,7 @@ COMMANDS = {
     install: Install,
     run: Run,
     daemon: Daemon,
-    tailf: Tailf,
-    help: Help
+    tailf: Tailf
 }
 
-def get_command_cls
-    
-    idx = ARGV.find_index { |arg| ! arg.start_with?( "-" ) }
-    
-    cmd_sym = idx ? ARGV.delete_at( idx ).to_sym : :help
- 
-    unless res = COMMANDS[ cmd_sym ]
-        res = Help
-        STDERR.puts( "Unrecognized command: #{cmd_sym}" )
-    end
-
-    res
-end
-
-BitGirderCliApplication.run( get_command_cls )
+BitGirderCliApplication.run_subcommand_app( commands: COMMANDS )

data/lib/bitgirder/core.rb

@@ -407,7 +407,9 @@ class BitGirderAttribute
 
     include BitGirderMethods
 
-    class InvalidModifier < RuntimeError; end
+    class AttributeError < RuntimeError; end
+    class InvalidModifier < AttributeError; end
+    class RedefinitionError < AttributeError; end
 
     PROCESSOR_BOOLEAN = lambda { |v| BitGirderMethods.to_bool( v ) }
 
@@ -421,6 +423,8 @@ class BitGirderAttribute
     # See PROCESSOR_INTEGER
     PROCESSOR_FLOAT = lambda { |v| v == nil ? nil : v.to_f }
 
+    PROCESSOR_EXPAND_PATH = lambda { |v| File.expand_path( v ) }
+
     VALIDATION_NOT_NIL = lambda { |val| raise "Missing value" if val == nil }
  
     # Implies not nil
@@ -482,10 +486,12 @@ class BitGirderAttribute
     def get_processor( p )
  
         case p
+            when nil, Proc then p
             when :boolean then PROCESSOR_BOOLEAN
             when :symbol then PROCESSOR_SYMBOL
             when :integer then PROCESSOR_INTEGER
             when :float then PROCESSOR_FLOAT
+            when :expand_path then PROCESSOR_EXPAND_PATH
 
             when Class
                 if p.ancestors.include?( BitGirderClass )
@@ -494,7 +500,7 @@ class BitGirderAttribute
                     raise ArgumentError, "Not a #{BitGirderClass}: #{p}"
                 end
 
-            else p
+            else raise "Unrecognized processor: #{p}"
         end
     end
 
@@ -556,18 +562,29 @@ class BitGirderClassDefinition
             instance_variable_set( :"@#{attr}", val )
         end
     end
-    
-    public
-    def add_attr( opts )
 
-        unless opts.key?( :required ) || opts.key?( :default )
-            opts[ :required ] = true
+    private
+    def read_add_attr_arg( arg )
+
+        case arg
+        when BitGirderAttribute then arg
+        when Hash
+            unless arg.key?( :required ) || arg.key?( :default )
+                arg[ :required ] = true
+            end
+            BitGirderAttribute.new( arg )
+        else raise "Don't know how to add as attr: #{arg}"
         end
+    end
+    
+    public
+    def add_attr( arg )
 
-        attr = BitGirderAttribute.new( opts )
+        attr = read_add_attr_arg( arg )
  
         if @attrs.key?( attr.identifier )
-            raise "Attribute #{attr.identifier.inspect} already defined"
+            msg = "Attribute #{attr.identifier.inspect} already defined"
+            raise BitGirderAttribute::RedefinitionError, msg
         else
             ident = attr.identifier
             @attrs[ ident ] = attr
@@ -976,6 +993,7 @@ class BitGirderCliApplication < BitGirderClass
             # attr.default could be the boolean false, which we still want to
             # display
             unless ( defl = attr.default ) == nil
+                defl = defl.call if defl.is_a?( Proc )
                 desc += " (Default: #{default_to_s( defl )})"
             end
 
@@ -1110,6 +1128,74 @@ class BitGirderCliApplication < BitGirderClass
         BitGirderMethods::not_nil( cls, :cls )
         self.new( :app_class => cls ).run( ARGV )
     end
+
+    class UnrecognizedSubcommandError < StandardError; end
+
+    def self.get_subcommand( commands )
+        
+        idx = ARGV.find_index { |arg| ! arg.start_with?( "-" ) }
+        
+        return nil unless idx
+
+        cmd_str = ARGV.delete_at( idx )
+        cmd_sym = cmd_str.gsub( "-", "_" ).to_sym
+ 
+        unless res = commands[ cmd_sym ]
+            raise UnrecognizedSubcommandError, cmd_str
+        end
+    
+        res
+    end
+
+    def self.show_subcommand_help( cmds )
+        
+        print "\ncommands:\n\n"
+
+        cmds.keys.sort.map { |s| s.to_s.gsub( "_", "-" ) }.
+             each { |s| puts "#{ " " * 4 }#{s}" }
+
+        puts
+    end
+
+    def self.run_subcommand_app( opts )
+
+        cmds = has_key( opts, :commands )
+        
+        cmd_cls = begin
+            self.get_subcommand( cmds )
+        rescue UnrecognizedSubcommandError => e
+            STDERR.puts( "Unrecognized command: #{e}" )
+        end
+
+        if cmd_cls
+            self.run( cmd_cls )
+        else
+            self.show_subcommand_help( cmds )
+        end
+    end
+end
+
+class AbstractApplication < BitGirderClass
+    
+    bg_abstract :impl_run
+
+    attr_reader :run_ctx, :argv_remain
+    attr_accessor :verbose
+
+    public
+    def verbose?
+        @verbose
+    end
+
+    public
+    def run( run_ctx )
+        
+        @run_ctx = run_ctx
+        @argv_remain = run_ctx[ :argv_remain ] || []
+        @verbose = run_ctx[ :verbose ]
+
+        impl_run
+    end
 end
 
 class ObjectPath

data/lib/bitgirder/io.rb

@@ -168,7 +168,7 @@ def as_write_dest( obj )
     not_nil( obj, :obj )
 
     case obj
-        when IO, Tempfile then yield( io )
+        when IO, Tempfile then yield( obj )
         when String then File.open( obj, "w" ) { |io| yield( io ) }
         else raise TypeError, "Unknown write dest: #{obj.class}"
     end
@@ -953,6 +953,12 @@ class UnixProcessBuilder < BitGirderClass
             IO.popen( get_call_argv18.join( " " ), mode, &blk )
         end
     end
+
+    [ :spawn, :exec, :system, :popen ].each do |meth|
+        self.class.send( :define_method, meth ) { |opts| 
+            self.new( opts ).send( meth )
+        }
+    end
 end
 
 end

data/lib/doc-gen17.rb

@@ -1,14 +0,0 @@
-
-# Autogenerated docs on 2012-11-21 11:47:21 -0800
-#
-
-# This code is only included for rdoc purposes and would not normally get
-# required. Even so, in case of overzealous scripts which might auto-require
-# this file, we enclose the entire body of this file in a guard that will
-# prevent it from being interpreted in an actual run
-#
-if false
-
-
-end # 'if false...' block
-

data/lib/doc-gen18.rb

@@ -0,0 +1,14 @@
+
+# Autogenerated docs on 2012-12-04 17:20:26 -0800
+#
+
+# This code is only included for rdoc purposes and would not normally get
+# required. Even so, in case of overzealous scripts which might auto-require
+# this file, we enclose the entire body of this file in a guard that will
+# prevent it from being interpreted in an actual run
+#
+if false
+
+
+end # 'if false...' block
+

data/lib/doc-gen20.rb

@@ -1,5 +1,5 @@
 
-# Autogenerated docs on 2012-11-21 11:47:21 -0800
+# Autogenerated docs on 2012-12-04 17:20:26 -0800
 #
 
 # This code is only included for rdoc purposes and would not normally get

data/lib/mingle.rb

@@ -332,8 +332,8 @@ class MingleTimestamp < MingleValue
         new( Time.at( secs ), false )
     end
 
-    # Impl :note => simply calling Time.at( ms / 1000.0 ) doesn't work as we might
-    # want, since it ends up passing a Float to Time.at() which apparently
+    # Impl :note => simply calling Time.at( ms / 1000.0 ) doesn't work as we
+    # might want, since it ends up passing a Float to Time.at() which apparently
     # performs more calculations or otherwise leads to a time which is close to
     # but not precisely the result of the division. To illustrate:
     #
@@ -1474,6 +1474,17 @@ class MingleParser < BitGirderClass
         end
     end
 
+    private
+    def exec_cast( ms, typ )
+        
+        begin
+            Mingle.cast_value( MingleString.new( ms ), typ )
+        rescue MingleTimestamp::Rfc3339FormatError => e
+            e = RestrictionTypeError.new( e.message ) if typ == TYPE_TIMESTAMP
+            raise e
+        end
+    end
+
     private
     def cast_range_value( val, nm, bound )
         
@@ -1490,7 +1501,7 @@ class MingleParser < BitGirderClass
         # s is a StringToken or a ParsedNumber
         s = val.is_a?( StringToken ) ? val.val : val.external_form
 
-        Mingle.cast_value( MingleString.new( s ), typ )
+        exec_cast( MingleString.new( s ), typ )
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitgirder-platform
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-21 00:00:00.000000000 Z
+date: 2012-12-05 00:00:00.000000000 Z
 dependencies: []
 description: Contains core classes and interfaces for building event logger implementations.
   Also includes helper classes for incorporating assertions about event logging into