cql-rb 1.0.0.pre0

data/README.md

@@ -0,0 +1,13 @@
+# Ruby CQL 3 driver
+
+This is a work in progress, no usable version exists yet.
+
+## Copyright
+
+Copyright 2013 Theo Hultberg
+
+_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](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._

data/bin/cqlexec

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'optparse'
+require 'set'
+require 'cql'
+
+
+class CqlExecutor
+  def initialize(args)
+    @options = parse_options!(args)
+  end
+
+  def run(io)
+    @client = Cql::Client.new(host: @options[:host], port: @options[:port]).start!
+
+    # TODO register for events
+
+    begin
+      buffer = ''
+      while (line = io.gets)
+        buffer << line
+        if semi_index = buffer.index(';')
+          query = buffer.slice!(0, semi_index + 1)
+          prepare_and_execute_request(query)
+        end
+      end
+      prepare_and_execute_request(buffer)
+    rescue Cql::CqlError => e
+      abort("Error: #{e.message} (#{e.class})")
+    rescue Interrupt
+      exit
+    ensure
+      @client.shutdown!
+    end
+  end
+
+  private
+
+  def parse_options!(args)
+    options = {}
+
+    option_parser = OptionParser.new do |opts|
+      opts.banner = "Usage: #{File.basename(__FILE__)} [options]"
+      opts.separator('')
+      opts.on('--help', 'Show this message') do
+        $stderr.puts(opts)
+        exit!
+      end
+      opts.on('-h', '--host [HOST]', 'Connect to HOST, defaults to localhost') do |host|
+        options[:host] = host
+      end
+      opts.on('-p', '--port [PORT]', Integer, 'Connect to PORT, defaults to 9042') do |port|
+        options[:port] = port
+      end
+      opts.on('-v', '--verbose', 'Print requests to STDERR') do |port|
+        options[:verbose] = true
+      end
+      opts.separator('')
+      opts.separator('Pass CQL commands on STDIN, prints results on STDOUT')
+      opts.separator('')
+    end
+
+    option_parser.parse!
+    
+    options
+  end
+
+  def prepare_and_execute_request(query)
+    query.chomp!(';')
+    query.strip!
+    unless query.empty?
+      format_table_output(@client.execute(query, :one))
+    end
+  end
+
+  def format_table_output(rows)
+    table_names = []
+    header = ''
+    row_format = ''
+    divider = ''
+    column_widths = {}
+    if rows && rows.any?
+      rows.metadata.each do |ks, table, column, type|
+        table_names << [ks, table].join('.')
+        column_width = [format_value(rows.first[column]).length, column.length].max
+        column_widths[column] = column_width
+        format = "%-#{column_width}.#{column_width}s"
+        header << "#{format} | " % [column]
+        row_format << "#{format} | "
+        divider << ('-' * column_width) << '-+-'
+      end
+      row_format.sub!(/ \| $/, '')
+      divider = divider[0..-4]
+      table_name = table_names.uniq.join(', ')
+
+      $stdout.puts(table_name)
+      $stdout.puts('=' * table_name.length)
+      $stdout.puts(header[0, divider.length])
+      $stdout.puts(divider)
+
+      rows.each do |row|
+        values = rows.metadata.map do |_, _, column, _|
+          limit_width(format_value(row[column]), column_widths[column])
+        end
+        $stdout.puts(row_format % values)
+      end
+    else
+      $stdout.puts('(empty result set)')
+    end
+  end
+
+  def format_value(value)
+    case value
+    when Set
+      value.to_a.to_s
+    when nil
+      '(nil)'
+    else
+      value.to_s
+    end
+  end
+
+  def limit_width(value, width)
+    if value.length > width
+      value[0, width - 1] << '…'
+    else
+      value
+    end
+  end
+end
+
+CqlExecutor.new(ARGV).run(STDIN)

data/lib/cql.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Cql
+  CqlError = Class.new(StandardError)
+end
+
+require 'cql/uuid'
+require 'cql/future'
+require 'cql/io'
+require 'cql/protocol'
+require 'cql/client'

data/lib/cql/client.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+module Cql
+  NotConnectedError = Class.new(CqlError)
+  InvalidKeyspaceNameError = Class.new(CqlError)
+
+  class QueryError < CqlError
+    attr_reader :code
+
+    def initialize(code, message)
+      super(message)
+      @code = code
+    end
+  end
+
+  class Client
+    def initialize(options={})
+      connection_timeout = options[:connection_timeout]
+      @host = options[:host] || 'localhost'
+      @port = options[:port] || 9042
+      @io_reactor = options[:io_reactor] || Io::IoReactor.new(connection_timeout: connection_timeout)
+      @lock = Mutex.new
+      @started = false
+      @shut_down = false
+      @initial_keyspace = options[:keyspace]
+      @connection_keyspaces = {}
+    end
+
+    def start!
+      @lock.synchronize do
+        return if @started
+        @started = true
+      end
+      @io_reactor.start
+      hosts = @host.split(',')
+      start_request = Protocol::StartupRequest.new
+      connection_futures = hosts.map do |host|
+        @io_reactor.add_connection(host, @port).flat_map do |connection_id|
+          execute_request(start_request, connection_id).map { connection_id }
+        end
+      end
+      @connection_ids = Future.combine(*connection_futures).get
+      use(@initial_keyspace) if @initial_keyspace
+      self
+    end
+
+    def shutdown!
+      @lock.synchronize do
+        return if @shut_down
+        @shut_down = true
+        @started = false
+      end
+      @io_reactor.stop.get
+      self
+    end
+
+    def keyspace
+      @lock.synchronize do
+        return @connection_ids.map { |id| @connection_keyspaces[id] }.first
+      end
+    end
+
+    def use(keyspace, connection_ids=@connection_ids)
+      raise NotConnectedError unless @started
+      if check_keyspace_name!(keyspace)
+        @lock.synchronize do
+          connection_ids = connection_ids.select { |id| @connection_keyspaces[id] != keyspace }
+        end
+        if connection_ids.any?
+          futures = connection_ids.map do |connection_id|
+            execute_request(Protocol::QueryRequest.new("USE #{keyspace}", :one), connection_id)
+          end
+          futures.compact!
+          Future.combine(*futures).get
+        end
+        nil
+      end
+    end
+
+    def execute(cql, consistency=:quorum)
+      result = execute_request(Protocol::QueryRequest.new(cql, consistency)).value
+      ensure_keyspace!
+      result
+    end
+
+    def execute_statement(connection_id, statement_id, metadata, values, consistency)
+      execute_request(Protocol::ExecuteRequest.new(statement_id, metadata, values, consistency), connection_id).value
+    end
+
+    def prepare(cql)
+      execute_request(Protocol::PrepareRequest.new(cql)).value
+    end
+
+    private
+
+    KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$/
+
+    def check_keyspace_name!(name)
+      if name !~ KEYSPACE_NAME_PATTERN
+        raise InvalidKeyspaceNameError, %("#{name}" is not a valid keyspace name)
+      end
+      true
+    end
+
+    def execute_request(request, connection_id=nil)
+      raise NotConnectedError unless @started
+      @io_reactor.queue_request(request, connection_id).map do |response, connection_id|
+        interpret_response!(response, connection_id)
+      end
+    end
+
+    def interpret_response!(response, connection_id)
+      case response
+      when Protocol::ErrorResponse
+        raise QueryError.new(response.code, response.message)
+      when Protocol::RowsResultResponse
+        QueryResult.new(response.metadata, response.rows)
+      when Protocol::PreparedResultResponse
+        PreparedStatement.new(self, connection_id, response.id, response.metadata)
+      when Protocol::SetKeyspaceResultResponse
+        @lock.synchronize do
+          @last_keyspace_change = @connection_keyspaces[connection_id] = response.keyspace
+        end
+        nil
+      else
+        nil
+      end
+    end
+
+    def ensure_keyspace!
+      ks = nil
+      @lock.synchronize do
+        ks = @last_keyspace_change
+        return unless @last_keyspace_change
+      end
+      use(ks, @connection_ids) if ks
+    end
+
+    class PreparedStatement
+      def initialize(*args)
+        @client, @connection_id, @statement_id, @metadata = args
+      end
+
+      def execute(*args)
+        @client.execute_statement(@connection_id, @statement_id, @metadata, args, :quorum)
+      end
+    end
+
+    class QueryResult
+      include Enumerable
+
+      attr_reader :metadata
+
+      def initialize(metadata, rows)
+        @metadata = ResultMetadata.new(metadata)
+        @rows = rows
+      end
+
+      def empty?
+        @rows.empty?
+      end
+
+      def each(&block)
+        @rows.each(&block)
+      end
+    end
+
+    class ResultMetadata
+      include Enumerable
+
+      def initialize(metadata)
+        @metadata = Hash[metadata.map { |m| mm = ColumnMetadata.new(*m); [mm.column_name, mm] }]
+      end
+
+      def [](column_name)
+        @metadata[column_name]
+      end
+
+      def each(&block)
+        @metadata.each_value(&block)
+      end
+    end
+
+    class ColumnMetadata
+      attr_reader :keyspace, :table, :table, :column_name, :type
+      
+      def initialize(*args)
+        @keyspace, @table, @column_name, @type = args
+      end
+
+      def to_ary
+        [@keyspace, @table, @column_name, @type]
+      end
+    end
+  end
+end

data/lib/cql/future.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+
+module Cql
+  FutureError = Class.new(CqlError)
+
+  class Future
+    def initialize
+      @complete_listeners = []
+      @failure_listeners = []
+      @value_barrier = Queue.new
+      @state_lock = Mutex.new
+    end
+
+    def self.combine(*futures)
+      CombinedFuture.new(*futures)
+    end
+
+    def self.completed(value=nil)
+      CompletedFuture.new(value)
+    end
+
+    def self.failed(error)
+      FailedFuture.new(error)
+    end
+
+    def complete!(v=nil)
+      @state_lock.synchronize do
+        raise FutureError, 'Future already completed' if complete? || failed?
+        @value = v
+        @complete_listeners.each do |listener|
+          listener.call(@value)
+        end
+      end
+    ensure
+      @state_lock.synchronize do
+        @value_barrier << :ping
+      end
+    end
+
+    def complete?
+      defined? @value
+    end
+
+    def on_complete(&listener)
+      @state_lock.synchronize do
+        if complete?
+          listener.call(value)
+        else
+          @complete_listeners << listener
+        end
+      end
+    end
+
+    def value
+      raise @error if @error
+      return @value if defined? @value
+      @value_barrier.pop
+      raise @error if @error
+      return @value
+    end
+    alias_method :get, :value
+
+    def fail!(error)
+      @state_lock.synchronize do
+        raise FutureError, 'Future already completed' if failed? || complete?
+        @error = error
+        @failure_listeners.each do |listener|
+          listener.call(error)
+        end
+      end
+    ensure
+      @state_lock.synchronize do
+        @value_barrier << :ping
+      end
+    end
+
+    def failed?
+      !!@error
+    end
+
+    def on_failure(&listener)
+      @state_lock.synchronize do
+        if failed?
+          listener.call(@error)
+        else
+          @failure_listeners << listener
+        end
+      end
+    end
+
+    def map(&block)
+      fp = Future.new
+      on_failure { |e| fp.fail!(e) }
+      on_complete do |v|
+        begin
+          vv = block.call(v)
+          fp.complete!(vv)
+        rescue => e
+          fp.fail!(e)
+        end
+      end
+      fp
+    end
+
+    def flat_map(&block)
+      fp = Future.new
+      on_failure { |e| fp.fail!(e) }
+      on_complete do |v|
+        begin
+          fpp = block.call(v)
+          fpp.on_failure { |e| fp.fail!(e) }
+          fpp.on_complete do |vv|
+            fp.complete!(vv)
+          end
+        rescue => e
+          fp.fail!(e)
+        end
+      end
+      fp
+    end
+  end
+
+  class CompletedFuture < Future
+    def initialize(value=nil)
+      super()
+      complete!(value)
+    end
+  end
+
+  class FailedFuture < Future
+    def initialize(error)
+      super()
+      fail!(error)
+    end
+  end
+
+  class CombinedFuture < Future
+    def initialize(*futures)
+      super()
+      values = [nil] * futures.size
+      completed = [false] * futures.size
+      futures.each_with_index do |f, i|
+        f.on_complete do |v|
+          all_done = false
+          @state_lock.synchronize do
+            values[i] = v
+            completed[i] = true
+            all_done = completed.all?
+          end
+          if all_done
+            combined_complete!(values)
+          end
+        end
+        f.on_failure do |e|
+          unless failed?
+            combined_fail!(e)
+          end
+        end
+      end
+    end
+
+    alias_method :combined_complete!, :complete!
+    private :combined_complete!
+
+    alias_method :combined_fail!, :fail!
+    private :combined_fail!
+
+    def complete!(v=nil)
+      raise FutureError, 'Cannot complete a combined future'
+    end
+
+    def fail!(e)
+      raise FutureError, 'Cannot fail a combined future'
+    end
+  end
+end