norikra-client 1.3.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3dbf7ff93daeb041efacdb5735068fb53ce9feda
+  data.tar.gz: db54c46353e386b05499a72f5e269f5e7271ea41
+SHA512:
+  metadata.gz: 55de95f13e671b42af92ec4666bd4b2a8b2ccf80218697b3053248430fc179e2b542a885e8312fb7e1d05f36e6c93dc4a4ea3cafd29033da85146f095a0b3155
+  data.tar.gz: 3b672c76011fd42ee68bf09263ed204d9ae6e36bd731772a847775230340ad725dd5e10a078890b04b6de604ad633495bedec997a7daa5071335f2dc4a35310b

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in norikra-client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TAGOMORI Satoshi
+
+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,186 @@
+# Norikra::Client (norikra-client)
+
+This is the client library implementation for Norikra, and its handy CLI commands.
+
+`Norikra` is CEP server, based on Esper. You can install `gem install norikra` on your JRuby.
+For more information, see http://norikra.github.io .
+
+Command `norikra-client` and module `Norikra::Client` are provided for both of CRuby and JRuby.
+
+ * For CRuby: `gem install norikra-client`
+ * For JRuby: `gem install norikra-client-jruby`
+
+Both have a same API and same data representaions. You can use which you want.
+
+## Commands
+
+Command `norikra-client` have some subcommands.
+
+    norikra-client -h
+    Commands:
+      norikra-client event CMD ...ARGS    # send/fetch events
+      norikra-client query CMD ...ARGS    # manage queries
+      norikra-client target CMD ...ARGS   # manage targets
+      norikra-client field CMD ...ARGS  # manage table field/datatype definitions
+      
+      norikra-client help [COMMAND]       # Describe available commands or one specific command
+    
+    Options:
+      [--host=HOST]
+                     # Default: localhost
+      [--port=N]
+                     # Default: 26571
+
+Of course, you can see helps of each subcommands by `norikra-client SUBCMD help`
+
+## Client Library
+
+In your programs, you can operate Norikra with Norikra::Client instances.
+
+    require 'norikra-client'
+    
+    client = Norikra::Client.new     # connect to localhost:26571
+    # client = Norikra::Client.new(hostname, portnum)
+
+## API
+
+### Norikra::Client.new(host, port, options={})
+
+Instanciate with server's hostname and port number.
+
+    require 'norikra-client'
+    client = Norikra::Client.new('norikra.server.local', 26571)
+
+Timeout options are available:
+
+    client = Norikra::Client.new(
+        'norikra.server.local',
+        26571,
+        connect_timeout: 3, send_timeout: 1, receive_timeout: 3
+    )
+
+### Norikra::Client#targets
+
+Returns list of hashes, which contains `name`(string) and `auto_fields`(true/false) of each targets.
+
+    client.targets #=> [{'name' => "demo", 'auto_field' => false}, {'name' => "sample", 'auto_field' => true}]
+
+### Norikra::Client#open(target_name, fields=nil, auto_field=true)
+
+Create new target on norikra server, to put events and queries. Returns true or false (successfully created, or already exists).
+
+    client.open('sample') #=> true
+
+Without fields, the specified target will be opend as 'lazy' mode, and actually opend when first input event arrived. Default field set will be determined at that time.
+
+With field definitions, `#open()` creates the target and actually opens it immediately.
+
+    client.open('sample', {id:'integer', name:'string', age:'integer', email:'string'})
+
+Fiels specified on `#open()` are configured as default field set.
+
+`auto_field` means which fields in arrived events are automatically added on field list, or not. Default is true.
+`auto_field: true` helps you to know What fields input event streams have. You can watch fields list on norikra, and write queries. But in cases your input streams have great many field name patterns, norikra returns long list of field names. That is not understandable. In these cases, you should specify `auto_field false`.
+
+In spite of `auto_field false`, norikra server adds fields which are used in registered queries automatically.
+
+### Norikra::Client#close
+
+Close the specified target. Norikra server stops all queries with that target.
+
+    client.close('sample')   #=> true
+
+### Norikra::Client#modify(target_name, auto_field)
+
+Modify the specified target configuration of auto_field.
+
+    client.modify('sample', false)   #=> true
+
+### Norikra::Client#queries
+
+Returns a list of hashes which contains `name`, `group`, `expression` and `targets` of registered queries.
+
+    client.queries #=> [{'name' => 'q1', 'group' => nil, 'expression' => 'select count(*) from sample ...', 'targets' => ['sample']}]
+
+Attributes of query:
+  * `name`: the name of query, that must be unique on norikra server
+  * `group`: the group name of query to be used in `sweep` call to fetch all events of queries with same `group` name (nil: default)
+  * `expression`: SQL expression
+  * `targets`: list of targets, which are referred in this SQL (2 or more targets by JOINs and SubQueries)
+
+### Norikra::Client#register(query_name, query_group, query_expression)
+
+Add query to norikra server. Query will be started immediately if all required targets/fields exists. If not, query actually starts when events arrived with all required fields.
+
+    client.register('q1', nil, 'select count(*) from sample.win:time_batch(1 min) where age >= 20')  #=> true
+
+### Norikra::Client#deregister(query_name)
+
+Stop and remove specified query immediately.
+
+    client.deregister('q1')   #=> true
+
+### Norikra::Client#suspend(query_name)
+
+Stop but does NOT remove specified query. Suspended queries are not recorded in stats file.
+
+    client.suspend('q1')   #=> true
+
+### Norikra::Client#resume(query_name)
+
+Re-run specified query, which is suspended previously.
+
+    client.resume('q1')    #=> true
+
+### Norikra::Client#fields(target)
+
+Returns the list of fields definitions, which contains `name`(string), `type`(string) and `optional`(true/false).
+
+    client.fields('sample') #=> [{'name' => 'id', 'type' => 'integer', 'optional' => false}, ...]
+
+NOTE: Hashes and arrays are just returned as 'hash' and 'array'. Nested fields and these types are not returned to client.
+
+### Norikra::Client#reserve(target, field_name, type)
+
+Specify the type of field, which not arrived yet.
+
+    client.reserve('sample', 'phone', 'string')  #=> true
+
+This api is useful for fields, which has int data at a time, and has string data at the other time. Norikra determines fields' type at the first time with that field, and format input data by determined type.
+If you want to parse as int for a field but that field's value may be either String or Integer, you should do `reserve()` to determine it as `int`.
+
+### Norikra::Client#send(target, events)
+
+Send list of input events into norikra server.
+
+    client.send('sample', [record1, record2, record3])
+
+Members of events should be hash instance, which has a field at least.
+Field values must be able to be serialized with MessagePack. Safe with String, Integer, Float, true/false/nil, Hash and Array.
+
+### Norikra::Client#event(query_name)
+
+Fetch events of specified query's output. Returns a list of `[time, event]`.
+
+    client.event('q1') #=> [ [1383297109,{"count(*)":50}], [1383297169,{"count(*)":37}], ... ]
+
+The first value of returned pairs is the time of output event as unix time (seconds from epoch).
+The second value is output record of query as Hash.
+
+### Norikra::Client#sweep(query_group=nil)
+
+Fetch all output events of queries of specified group. `query_group: nil` means default query group. Returns Hash instance like `'query_name' => [list of output (same as #event)]`
+
+    client.sweep() #=> for default group
+    client.sweep('my_secret_group')
+
+## Versions
+
+* v0.1.0:
+ * First release for production
+
+## Copyright
+
+* Copyright (c) 2013- TAGOMORI Satoshi (tagomoris)
+* License
+  * MIT License

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/norikra-client

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+lib = Pathname.new(__FILE__).dirname.join('..', 'lib').expand_path
+$LOAD_PATH.unshift lib.to_s
+
+require 'norikra/client/cli'
+Norikra::Client::CLI.start

data/lib/norikra-client.rb

@@ -0,0 +1 @@
+require 'norikra/client'

data/lib/norikra/client.rb

@@ -0,0 +1,91 @@
+require "norikra/client/version"
+
+require 'msgpack-rpc-over-http'
+
+module Norikra
+  module RPC
+    class ClientError < MessagePack::RPCOverHTTP::RemoteError; end
+    class ServerError < MessagePack::RPCOverHTTP::RemoteError; end
+    class ServiceUnavailableError < MessagePack::RPCOverHTTP::RemoteError; end
+  end
+
+  class Client
+    RPC_DEFAULT_PORT = 26571
+    TIMEOUT_OPTIONS = [:connect_timeout, :send_timeout, :receive_timeout]
+
+    def initialize(host='localhost', port=RPC_DEFAULT_PORT, opts={})
+      @client = MessagePack::RPCOverHTTP::Client.new("http://#{host}:#{port}/")
+
+      @client.connect_timeout = opts[:connect_timeout] if opts.has_key?(:connect_timeout) && @client.respond_to?('connect_timeout='.to_sym)
+      @client.send_timeout    = opts[:send_timeout]    if opts.has_key?(:send_timeout)    && @client.respond_to?('send_timeout='.to_sym)
+      @client.receive_timeout = opts[:receive_timeout] if opts.has_key?(:receive_timeout) && @client.respond_to?('receive_timeout='.to_sym)
+    end
+
+    def targets
+      @client.call(:targets) #=> {:name => "name", :auto_field => true}
+    end
+
+    def open(target, fields=nil, auto_field=true)
+      @client.call(:open, target, fields, auto_field)
+    end
+
+    def close(target)
+      @client.call(:close, target)
+    end
+
+    def modify(target, auto_field)
+      @client.call(:modify, target, auto_field)
+    end
+
+    def queries
+      @client.call(:queries)
+    end
+
+    def register(query_name, query_group, query_expression)
+      @client.call(:register, query_name, query_group, query_expression)
+    end
+
+    def deregister(query_name)
+      @client.call(:deregister, query_name)
+    end
+
+    def suspend(query_name)
+      @client.call(:suspend, query_name)
+    end
+
+    def resume(query_name)
+      @client.call(:resume, query_name)
+    end
+
+    def fields(target)
+      @client.call(:fields, target)
+    end
+
+    def reserve(target, field, type)
+      @client.call(:reserve, target, field, type)
+    end
+
+    def send(target, events)
+      @client.call(:send, target, events)
+    end
+
+    # [ [time, event], ... ]
+    def event(query_name)
+      @client.call(:event, query_name)
+    end
+
+    # [ [time, event], ... ]
+    def see(query_name)
+      @client.call(:see, query_name)
+    end
+
+    # {'query_name' => [ [time, event], ... ]}
+    def sweep(query_group=nil)
+      @client.call(:sweep, query_group)
+    end
+
+    def logs
+      @client.call(:logs)
+    end
+  end
+end

data/lib/norikra/client/cli.rb

@@ -0,0 +1,302 @@
+require 'thor'
+require 'norikra/client'
+
+require 'norikra/client/cli/parser'
+require 'norikra/client/cli/formatter'
+
+class Norikra::Client
+  module CLIUtil
+    def client(options)
+      Norikra::Client.new(options[:host], options[:port])
+    end
+    def wrap
+      begin
+        yield
+      rescue Norikra::RPC::ClientError => e
+        puts "Failed: " + e.message
+      rescue Norikra::RPC::ServerError => e
+        puts "ERROR on norikra server: " + e.message
+        puts " For more details, see norikra server's logs"
+      end
+    end
+  end
+
+  class Target < Thor
+    include Norikra::Client::CLIUtil
+
+    desc "list", "show list of targets"
+    option :simple, :type => :boolean, :default => false, :desc => "suppress header/footer", :aliases => "-s"
+    def list
+      wrap do
+        puts ["TARGET","AUTO_FIELD"].join("\t") unless options[:simple]
+        targets = client(parent_options).targets
+        targets.each do |t|
+          puts [t['name'], t['auto_field']].join("\t")
+        end
+        puts "#{targets.size} targets found." unless options[:simple]
+      end
+    end
+
+    desc "open TARGET [fieldname1:type1 [fieldname2:type2 [fieldname3:type3] ...]]", "create new target (and define its fields)"
+    option :suppress_auto_field, :type => :boolean, :default => false, :desc => "suppress to define fields automatically", :aliases => "-x"
+    def open(target, *field_defs)
+      fields = nil
+      if field_defs.size > 0
+        fields = {}
+        field_defs.each do |str|
+          fname,ftype = str.split(':')
+          fields[fname] = ftype
+        end
+      end
+      auto_field = (not options[:suppress_auto_field])
+
+      wrap do
+        client(parent_options).open(target, fields, auto_field)
+      end
+    end
+
+    desc "close TARGET", "close existing target and all its queries"
+    def close(target)
+      wrap do
+        client(parent_options).close(target)
+      end
+    end
+
+    desc "modify TARGET BOOL_VALUE", "modify target to do define fields automatically or not"
+    def modify(target, val)
+      auto_field = ['yes','true','auto'].include?(val.downcase)
+      wrap do
+        client(parent_options).modify(target, auto_field)
+      end
+    end
+  end
+
+  class Query < Thor
+    include Norikra::Client::CLIUtil
+
+    desc "list", "show list of queries"
+    option :simple, :type => :boolean, :default => false, :desc => "suppress header/footer", :aliases => "-s"
+    def list
+      wrap do
+        puts ["NAME", "GROUP", "TARGETS", "SUSPENDED", "QUERY"].join("\t") unless options[:simple]
+        queries = client(parent_options).queries
+        queries.sort{|a,b| (a['targets'].first <=> b['targets'].first).nonzero? || a['name'] <=> b['name']}.each do |q|
+          puts [
+            q['name'],
+            (q['group'] || 'default'),
+            q['targets'].join(','),
+            q['suspended'].to_s,
+            q['expression'].split("\n").map(&:strip).join(" ")
+          ].join("\t")
+        end
+        puts "#{queries.size} queries found." unless options[:simple]
+      end
+    end
+
+    desc "add QUERY_NAME QUERY_EXPRESSION", "register a query"
+    option :group, :type => :string, :default => nil, :desc => "query group for sweep/listen (default: null)", :aliases => "-g"
+    def add(query_name, expression)
+      wrap do
+        client(parent_options).register(query_name, options[:group], expression)
+      end
+    end
+
+    desc "remove QUERY_NAME", "deregister a query"
+    def remove(query_name)
+      wrap do
+        client(parent_options).deregister(query_name)
+      end
+    end
+
+    desc "suspend QUERY_NAME", "specify to stop (but not removed)"
+    def suspend(query_name)
+      wrap do
+        client(parent_options).suspend(query_name)
+      end
+    end
+
+    desc "resume QUERY_NAME", "specify to re-run query suspended before"
+    def resume(query_name)
+      wrap do
+        client(parent_options).resume(query_name)
+      end
+    end
+  end
+
+  class Field < Thor
+    include Norikra::Client::CLIUtil
+
+    desc "list TARGET", "show list of field definitions of specified target"
+    option :simple, :type => :boolean, :default => false, :desc => "suppress header/footer", :aliases => "-s"
+    def list(target)
+      wrap do
+        puts "FIELD\tTYPE\tOPTIONAL" unless options[:simple]
+        fields = client(parent_options).fields(target)
+        fields.each do |f|
+          puts "#{f['name']}\t#{f['type']}\t#{f['optional']}"
+        end
+        puts "#{fields.size} fields found." unless options[:simple]
+      end
+    end
+
+    desc "add TARGET FIELDNAME TYPE", "reserve fieldname and its type of target"
+    def add(target, field, type)
+      wrap do
+        client(parent_options).reserve(target, field, type)
+      end
+    end
+  end
+
+  class Event < Thor
+    include Norikra::Client::CLIUtil
+
+    desc "send TARGET", "send data into targets"
+    option :format, :type => :string, :default => 'json', :desc => "format of input data per line of stdin [json(default), ltsv]"
+    option :batch_size, :type => :numeric, :default => 10000, :desc => "records sent in once transferring (default: 10000)"
+    def send(target)
+      client = client(parent_options)
+      parser = parser(options[:format])
+      buffer = []
+      $stdin.each_line do |line|
+        buffer.push(parser.parse(line))
+        if buffer.size >= options[:batch_size]
+          client.send(target, buffer)
+          buffer = []
+        end
+      end
+
+      wrap do
+        client.send(target, buffer) if buffer.size > 0
+      end
+    end
+
+    desc "fetch QUERY_NAME", "fetch events from specified query"
+    option :format, :type => :string, :default => 'json', :desc => "format of output data per line of stdout [json(default), ltsv]"
+    option :time_key, :type => :string, :default => 'time', :desc => "output key name for event time (default: time)"
+    option :time_format, :type => :string, :default => '%Y/%m/%d %H:%M:%S', :desc => "output time format (default: '2013/05/14 17:57:59')"
+    def fetch(query_name)
+      formatter = formatter(options[:format])
+      time_formatter = lambda{|t| Time.at(t).strftime(options[:time_format])}
+
+      wrap do
+        client(parent_options).event(query_name).each do |time,event|
+          event = {options[:time_key] => Time.at(time).strftime(options[:time_format])}.merge(event)
+          puts formatter.format(event)
+        end
+      end
+    end
+
+    desc "see QUERY_NAME", "see events of specified query, but not delete"
+    option :format, :type => :string, :default => 'json', :desc => "format of output data per line of stdout [json(default), ltsv]"
+    option :time_key, :type => :string, :default => 'time', :desc => "output key name for event time (default: time)"
+    option :time_format, :type => :string, :default => '%Y/%m/%d %H:%M:%S', :desc => "output time format (default: '2013/05/14 17:57:59')"
+    def see(query_name)
+      formatter = formatter(options[:format])
+      time_formatter = lambda{|t| Time.at(t).strftime(options[:time_format])}
+
+      wrap do
+        client(parent_options).see(query_name).each do |time,event|
+          event = {options[:time_key] => Time.at(time).strftime(options[:time_format])}.merge(event)
+          puts formatter.format(event)
+        end
+      end
+    end
+
+    desc "sweep [query_group_name]", "fetch all output events of all queries of default (or specified) query group"
+    option :format, :type => :string, :default => 'json', :desc => "format of output data per line of stdout [json(default), ltsv]"
+    option :query_name_key, :type => :string, :default => 'query', :desc => "output key name for query name (default: query)"
+    option :time_key, :type => :string, :default => 'time', :desc => "output key name for event time (default: time)"
+    option :time_format, :type => :string, :default => '%Y/%m/%d %H:%M:%S', :desc => "output time format (default: '2013/05/14 17:57:59')"
+    def sweep(query_group=nil)
+      wrap do
+        formatter = formatter(options[:format])
+        time_formatter = lambda{|t| Time.at(t).strftime(options[:time_format])}
+
+        data = client(parent_options).sweep(query_group)
+
+        data.keys.sort.each do |queryname|
+          events = data[queryname]
+          events.each do |time,event|
+            event = {
+              options[:time_key] => Time.at(time).strftime(options[:time_format]),
+              options[:query_name_key] => queryname,
+            }.merge(event)
+            puts formatter.format(event)
+          end
+        end
+      end
+    end
+  end
+
+  class Admin < Thor
+    include Norikra::Client::CLIUtil
+
+    desc "stats", "dump stats json: same with norikra server's --stats option"
+    def stats
+      opt = parent_options
+      client = client(parent_options)
+
+      targets = []
+      queries = []
+
+      wrap do
+        queries = client.queries()
+
+        client.targets().each do |t|
+          fields = {}
+          client.fields(t['name']).each do |f|
+            next if f['type'] == 'hash' || f['type'] == 'array'
+            fields[f['name']] = f
+          end
+          targets.push( { "name" => t['name'], "fields" => fields, "auto_field" => t['auto_field'] } )
+        end
+      end
+
+      require 'json'
+
+      puts JSON.pretty_generate({
+          "threads" => {
+            "engine" => { "inbound" => {}, "outbound" => {}, "route_exec" => {}, "timer_exec" => {} },
+            "rpc" => {},
+            "web" => {},
+          },
+          "log" => {},
+          "targets" => targets,
+          "queries" => queries,
+        })
+    end
+
+    desc "logs", "get and print Norikra server logs"
+    def logs
+      opt = parent_options
+      client = client(parent_options)
+      wrap do
+        client.logs().each do |time, level, line|
+          puts "#{time} [#{level}] #{line}"
+        end
+      end
+    end
+  end
+
+  class CLI < Thor
+    include Norikra::Client::CLIUtil
+
+    class_option :host, :type => :string, :default => 'localhost'
+    class_option :port, :type => :numeric, :default => 26571
+
+    desc "target CMD ...ARGS", "manage targets"
+    subcommand "target", Target
+
+    desc "field CMD ...ARGS", "manage target field/datatype definitions"
+    subcommand "field", Field
+
+    desc "query CMD ...ARGS", "manage queries"
+    subcommand "query", Query
+
+    desc "event CMD ...ARGS", "send/fetch events"
+    subcommand "event", Event
+
+    desc "admin CMD ...ARGS", "norikra server administrations"
+    subcommand "admin", Admin
+  end
+end

data/lib/norikra/client/cli/formatter.rb

@@ -0,0 +1,35 @@
+module Norikra::Client::CLIUtil
+  def formatter(format, *args)
+    format ||= 'json'
+    case format
+    when /^json$/i
+      require 'json'
+      Formatter::JSON.new(*args)
+    when /^ltsv$/i
+      require 'ltsv'
+      Formatter::LTSV.new(*args)
+    else
+      raise ArgumentError, "unknown format name: #{format}"
+    end
+  end
+
+  module Formatter
+    class JSON
+      def initialize(*args)
+        require 'json'
+      end
+      def format(obj)
+        ::JSON.dump(obj)
+      end
+    end
+
+    class LTSV
+      def initialize(*args)
+        require 'ltsv'
+      end
+      def format(obj)
+        ::LTSV.dump(obj)
+      end
+    end
+  end
+end

data/lib/norikra/client/cli/parser.rb

@@ -0,0 +1,35 @@
+module Norikra::Client::CLIUtil
+  def parser(format, *args)
+    format ||= 'json'
+    case format
+    when /^json$/i
+      require 'json'
+      Parser::JSON.new(*args)
+    when /^ltsv$/i
+      require 'ltsv'
+      Parser::LTSV.new(*args)
+    else
+      raise ArgumentError, "unknown format name: #{format}"
+    end
+  end
+
+  module Parser
+    class JSON
+      def initialize(*args)
+        require 'json'
+      end
+      def parse(line)
+        ::JSON.parse(line.chop)
+      end
+    end
+
+    class LTSV
+      def initialize(*args)
+        require 'ltsv'
+      end
+      def parse(line)
+        ::LTSV.parse_line(line.chop, {:symbolize_keys => false})
+      end
+    end
+  end
+end

data/lib/norikra/client/version.rb

@@ -0,0 +1,5 @@
+module Norikra
+  class Client
+    VERSION = "1.3.0"
+  end
+end

data/norikra-client.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'norikra/client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "norikra-client"
+  spec.version       = Norikra::Client::VERSION
+
+  if /java/ =~ RUBY_PLATFORM
+    spec.platform      = "java"
+  end
+
+  spec.authors       = ["TAGOMORI Satoshi"]
+  spec.email         = ["tagomoris@gmail.com"]
+  spec.description   = %q{Client commands and libraries for Norikra}
+  spec.summary       = %q{Client commands and libraries for Norikra}
+  spec.homepage      = "https://github.com/norikra/norikra-client-ruby"
+  spec.license       = "APLv2"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "msgpack-rpc-over-http", ">= 0.0.7"
+  spec.add_runtime_dependency "thor"
+  spec.add_runtime_dependency "ltsv"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: norikra-client
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: java
+authors:
+- TAGOMORI Satoshi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  name: msgpack-rpc-over-http
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: thor
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: ltsv
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Client commands and libraries for Norikra
+email:
+- tagomoris@gmail.com
+executables:
+- norikra-client
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/norikra-client
+- lib/norikra-client.rb
+- lib/norikra/client.rb
+- lib/norikra/client/cli.rb
+- lib/norikra/client/cli/formatter.rb
+- lib/norikra/client/cli/parser.rb
+- lib/norikra/client/version.rb
+- norikra-client.gemspec
+homepage: https://github.com/norikra/norikra-client-ruby
+licenses:
+- APLv2
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Client commands and libraries for Norikra
+test_files: []
+has_rdoc: