cassandra-web 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 3a6f4cd8f179852f512ed15d970fa047b9bd8e34
-  data.tar.gz: 72e44f686c76317e73080cba9cff33eca6eddd5d
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDIxN2VhZDIyOGQwMmQzM2M3ZjUyMjg0ZTMwNDU5MWZhZmM2ODljZg==
+  data.tar.gz: !binary |-
+    OTAxYjlmNWQ5ZDI2Y2FiZjUyMjdhMGExNzZkYzk4NTEzZTI5N2VhMw==
 SHA512:
-  metadata.gz: b5bbf71fef357fd138aa3fe3f968cc3e5f01a0e22660046757e03f59e38442727d5d4f5abd7884caaf6adb6f0babf6d0b8b9a4e6043904d7e186f3789e8d1f98
-  data.tar.gz: cc7b0010c460da1b01b95d07f195650cec356e4fd9e779552ef16403fc183085459bb534dd95c6d23a4ac7c0ce68b0ba25f8909e74b25a79eb65885c208d5ac0
+  metadata.gz: !binary |-
+    Njc2ODUzMjc4YzE0NTczYmFmMDQ4MmNhZGRhZmMxZTFiNmNjNzdjZDE2OGQy
+    OTI3ZTlmZTNiOTVjZTAxNWY5NmUwZjc0ZDU2MjI2YTg0ZWEwZmEzODg3YzUz
+    MWY1ZGFiOTNkNDkxMTgxYmQxYWM4NTFiYTRhOGIxMzIxYzRhMWM=
+  data.tar.gz: !binary |-
+    Yjc2MGM5MmExMDNjMzY3ZmM4YWVkMTZjYzI0OTllZDFkNzkyZTRkMmQ5ZWQx
+    NGI3YWE3ZWIxN2M3MjliMDIzZTk4MmM1NGVmMzZkZWJjNzliYTQyMzA2MzJm
+    YTMwZjU4ZDc5ZGRiMjc5Mzc5ZTEwMGJmMDBjM2Q4ZjY1MGYwMDQ=

data/README.md

@@ -2,20 +2,47 @@
 
 A web interface to Apache Cassandra with AngularJS and server-sent events.
 
-## Quick Start
+## Installation
 
 ```bash
-gem install cassandra-web
-cassandra-web
+$ gem install cassandra-web
 ```
 
-Run `cassandra-web -h` for futher help
+## Usage
+
+```bash
+$ cassandra-web
+```
+
+Run `cassandra-web -h` for futher help.
+
+## How it works
+
+Cassandra web consists of an HTTP API powered by [Sinatra](https://github.com/sinatra/sinatra) and a thin HTML5/JavaScript frontend powered by [AngularJS](https://angularjs.org/).
+
+When you run `cassandra-web` script, it starts a [Thin web server](http://code.macournoyer.com/thin/) on a specified address, which defaults to `localhost:3000`. Openning `http://localhost:3000`, or whatever address you've specified in the browser, loads the AngularJS application and it starts interacting with the HTTP API of `cassandra-web`. This api uses the [Ruby Driver](http://datastax.github.io/ruby-driver/) to communicate with an [Apache Cassandra](http://cassandra.apache.org/) cluster.
+
+When the frontend has fully loaded, [it subscribes to `/events` API endpoint](https://github.com/avalanche123/cassandra-web/blob/master/app/public/js/cassandra.js#L108), and begins receiving [Server Sent Events](http://www.w3.org/TR/2012/WD-eventsource-20120426/). [The API uses an event listener, which is registered with the `Cluster` instance created by the Ruby Driver, to stream events](https://github.com/avalanche123/cassandra-web/blob/master/app/helpers/sse.rb#L43-L56) such as [schema](https://github.com/avalanche123/cassandra-web/blob/master/app/helpers/sse.rb#L29-L39) and [node status](https://github.com/avalanche123/cassandra-web/blob/master/app/helpers/sse.rb#L13-L27) changes to update the user interface without having to refresh the page.
+
+You can see this feature in action by creating a keyspace using the execute button in the top-right corner of the UI and executing the following statement:
+
+```cql
+CREATE KEYSPACE example WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}
+```
+
+If the statement executed successfully, you should see a new keyspace show up on the left side of the UI.
+
+![Alt text](https://raw.githubusercontent.com/avalanche123/cassandra-web/master/animation.gif "Create Keyspace")
+
+The web server, Thin, used by `cassandra-web` is asynchronous and uses only a single thread to handle requests. This enables efficient handling multiple of long running connections, which is a requirement for streaming and Server Sent Events, but also means that the application cannot perform blocking operations during request handling, since it would hang up all connections for the duration of the blocking operation. `cassandra-web` therefore uses Asynchronous Execution feature of the Ruby Driver to not block on statements execution. [The application executes statements asynchronously, receiving a future from the Ruby Driver](https://github.com/avalanche123/cassandra-web/blob/master/app.rb#L88). [It then registers future completion listeners to send a response (or error) whenever it becomes available](https://github.com/avalanche123/cassandra-web/blob/master/app/helpers/async.rb#L7-L40).
 
 ## Credits
 
 Cassandra web is possible because of the following awesome technologies (in no particular order):
 
   * [Apache Cassandra](http://cassandra.apache.org/)
+  * [DataStax Ruby Driver for Apache Cassandra](http://datastax.github.io/ruby-driver/)
+  * [Sinatra](https://github.com/sinatra/sinatra)
   * [AngularJS](https://angularjs.org/)
   * [Twitter Bootstrap](http://getbootstrap.com/)
   * [Thin](http://code.macournoyer.com/thin/)

data/app.rb

@@ -43,7 +43,7 @@ class App < Sinatra::Base
     headers 'Connection' => 'keep-alive'
 
     stream(:keep_open) do |out|
-      send_events(out)
+      stream_events(out)
     end
   end
 
@@ -71,33 +71,21 @@ class App < Sinatra::Base
   post '/execute/?' do
     content_type 'application/json'
 
-    begin
-      statement = params['statement']
-      statement.strip!
-      statement.chomp!(";")
-
-      options = {
-        :consistency => :one,
-        :trace => false
-      }
-
-      if params['options']
-        options[:trace]       = !!params['options']['trace'] if params['options'].has_key?('trace')
-        options[:consistency] = params['options']['consistency'].to_sym if params['options'].has_key?('consistency') && Cassandra::CONSISTENCIES.include?(params['options']['consistency'].to_sym)
-      end
-
-      status 200
-      json_dump(session.execute(statement, options))
-    rescue Cassandra::Errors::NoHostsAvailable => e
-      status 503
-      json_dump(e)
-    rescue Cassandra::Errors::QueryError => e
-      status 400
-      json_dump(e)
-    rescue => e
-      status 500
-      json_dump(e)
+    statement = params['statement']
+    statement.strip!
+    statement.chomp!(";")
+
+    options = {
+      :consistency => :one,
+      :trace => false
+    }
+
+    if params['options']
+      options[:trace]       = !!params['options']['trace'] if params['options'].has_key?('trace')
+      options[:consistency] = params['options']['consistency'].to_sym if params['options'].has_key?('consistency') && Cassandra::CONSISTENCIES.include?(params['options']['consistency'].to_sym)
     end
+
+    defer(session.execute_async(statement, options))
   end
 
   get '*' do
@@ -105,8 +93,10 @@ class App < Sinatra::Base
   end
 end
 
+require 'app/helpers/async'
 require 'app/helpers/json'
 require 'app/helpers/sse'
 
+App.helpers  App::Helpers::Async
 App.helpers  App::Helpers::JSON
 App.helpers  App::Helpers::SSE

data/app/helpers/async.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+class App
+  module Helpers
+    module Async
+      def defer(future)
+        future.on_success do |result|
+          env["async.callback"].call([
+            200,
+            {
+              'Content-Type' => 'application/json'
+            },
+            [json_dump(result)]
+          ])
+        end
+
+        future.on_failure do |error|
+          status = case error
+          when Cassandra::Errors::NoHostsAvailable
+            503
+          when Cassandra::Errors::AuthenticationError
+            401
+          when Cassandra::Errors::UnauthorizedError
+            403
+          when Cassandra::Errors::ExecutionError
+            504
+          when Cassandra::Error
+            400
+          when
+            500
+          end
+
+          env["async.callback"].call([
+            status,
+            {
+              'Content-Type' => 'application/json'
+            },
+            [json_dump(error)]
+          ])
+        end
+
+        throw :async
+      end
+    end
+  end
+end

data/app/helpers/json.rb

@@ -17,12 +17,8 @@ class App
           keyspace_hash(object)
         when ::Cassandra::Result
           result_hash(object)
-        when ::Cassandra::Errors::NoHostsAvailable
-          no_hosts_available_error_hash(object)
-        when ::Cassandra::Errors::QueryError
-          query_error_hash(object)
         when ::Exception
-          error_hash(object)
+          exception_hash(object)
         when ::Hash
           hash = ::Hash.new
           object.each do |key, value|
@@ -98,14 +94,14 @@ class App
       def result_hash(result)
         {
           :rows    => result.map(&method(:object_hash)),
-          :columns => columns_hash(result.first),
+          :columns => columns_hash(result),
           :info    => execution_info_hash(result.execution_info),
         }
       end
 
-      def columns_hash(row)
-        return [] if row.nil?
-        row.keys
+      def columns_hash(rows)
+        return [] if rows.empty?
+        rows.first.keys
       end
 
       def execution_info_hash(execution_info)
@@ -159,19 +155,92 @@ class App
       end
 
       def error_hash(error)
+        case error
+        when ::Cassandra::Errors::NoHostsAvailable
+          no_hosts_available_error_hash(error)
+        when ::Cassandra::Errors::ReadTimeoutError
+          read_timeout_error_hash(error)
+        when ::Cassandra::Errors::WriteTimeoutError
+          write_timeout_error_hash(error)
+        when ::Cassandra::Errors::UnavailableError
+          unavailable_error_hash(error)
+        when ::Cassandra::Errors::UnpreparedError
+          unprepared_error_hash(error)
+        when ::Cassandra::Errors::AlreadyExistsError
+          already_exists_error_hash(error)
+        when ::Cassandra::Errors::ExecutionError, ::Cassandra::Errors::ValidationError
+          execution_error_hash(error)
+        else
+          exception_hash(error)
+        end
+      end
+
+      def exception_hash(error)
         {
           :class   => error.class.name,
           :message => error.message,
-          :trace    => error.backtrace
+          :trace   => error.backtrace
         }
       end
 
-      def query_error_hash(error)
-        error_hash(error)
+      def execution_error_hash(error)
+        hash = exception_hash(error)
+        hash[:statement] = statement_hash(error.statement)
+        hash
+      end
+
+      def already_exists_error_hash(error)
+        hash = execution_error_hash(error)
+        hash[:keyspace] = error.keyspace
+        hash[:table]    = error.table
+        hash
+      end
+
+      def unprepared_error_hash(error)
+        hash = execution_error_hash(error)
+        hash[:id] = error.id
+        hash
+      end
+
+      def read_timeout_error_hash(error)
+        hash = execution_error_hash(error)
+        hash[:retrieved]   = error.retrieved?
+        hash[:consistency] = error.consistency
+        hash[:required]    = error.required
+        hash[:received]    = error.received
+        hash
+      end
+
+      def write_timeout_error_hash(error)
+        hash = execution_error_hash(error)
+        hash[:type]        = error.type
+        hash[:consistency] = error.consistency
+        hash[:required]    = error.required
+        hash[:received]    = error.received
+        hash
+      end
+
+      def unavailable_error_hash(error)
+        hash = execution_error_hash(error)
+        hash[:consistency] = error.consistency
+        hash[:required]    = error.required
+        hash[:alive]       = error.alive
+        hash
       end
 
       def no_hosts_available_error_hash(error)
-        error_hash(error)
+        hash = exception_hash(error)
+        errors = []
+
+        error.errors.each do |host, e|
+          errors << {
+            :host  => host_hash(host),
+            :error => error_hash(e)
+          }
+        end
+
+        hash[:errors] = errors
+        hash
       end
     end
   end

data/app/helpers/sse.rb

@@ -39,7 +39,7 @@ class App
         end
       end
 
-      def send_events(out)
+      def stream_events(out)
         listener  = Streamer.new(out)
         heartbeat = EM.add_periodic_timer(2) { out << "\n" }
 

data/bin/cassandra-web

@@ -21,16 +21,20 @@ class CLI
     @parser  = OptionParser.new
     @options = {
       :bind      => '0.0.0.0:3000',
-      :log_level => 'debug'
+      :log_level => 'info'
     }
 
-    option(:bind,        '-B', '--bind BIND',        String,  'ip:port or path for cassandra web to bind on')
-    option(:hosts,       '-H', '--hosts HOSTS',      String,  'coma-separated list of cassandra hosts')
-    option(:port,        '-P', '--port PORT',        Integer, 'integer port that cassandra is running on')
+    option(:bind,        '-B', '--bind BIND',        String,  'ip:port or path for cassandra web to bind on (default: 0.0.0.0:3000)')
+    option(:hosts,       '-H', '--hosts HOSTS',      String,  'coma-separated list of cassandra hosts (default: 127.0.0.1)')
+    option(:port,        '-P', '--port PORT',        Integer, 'integer port that cassandra is running on (default: 9042)')
+    option(:log_level,   '-L', '--log-level LEVEL',  String,  'log level (default: info)')
     option(:username,    '-u', '--username USER',    String,  'username to use when connecting to cassandra')
     option(:password,    '-p', '--password PASS',    String,  'password to use when connecting to cassandra')
     option(:compression, '-C', '--compression NAME', String,  'compression algorithm to use (lz4 or snappy)')
-    option(:log_level,   '-L', '--log-level LEVEL',  String,  'log level')
+    option(:server_cert, '--server-cert PATH',       String,  'server ceritificate pathname')
+    option(:client_cert, '--client-cert PATH',       String,  'client ceritificate pathname')
+    option(:private_key, '--private-key PATH',       String,  'path to private key')
+    option(:passphrase,  '--passphrase SECRET',      String,  'passphrase for the private key')
 
     @parser.on('-h', '--help', 'Show help') { show_help }
   end
@@ -45,14 +49,17 @@ class CLI
 
     @options.each do |name, value|
       value = case name
-      when :hosts       then value.split(',').map!(&:strip)
-      when :compression then value.downcase.to_sym
-      when :port, :username, :password
+      when :port, :username, :password # skip as is
+      when :hosts
+        value.split(',').map!(&:strip)
+      when :compression
+        value.downcase.to_sym
       when :log_level
-        name   = :logger
-        Logger.new(@out).tap do |logger|
-          logger.level = Logger.const_get(value.upcase.to_sym)
-        end
+        name = :logger
+
+        logger       = Logger.new(@out)
+        logger.level = Logger.const_get(value.upcase.to_sym)
+        logger
       else
         next
       end
@@ -60,7 +67,14 @@ class CLI
       options[name] = value
     end
 
-    cluster = ::Cassandra.connect(options)
+    hosts = Array(options[:hosts])
+    hosts << '127.0.0.1' if hosts.empty?
+
+    options[:load_balancing_policy] = ::Cassandra::LoadBalancing::Policies::WhiteList.new(hosts, ::Cassandra::LoadBalancing::Policies::RoundRobin.new)
+    options[:compression]           = :lz4
+    options[:page_size]             = nil
+
+    cluster = ::Cassandra.cluster(options)
 
     App.set(:cluster, cluster)
     App.set(:session, cluster.connect)

metadata

@@ -1,113 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: cassandra-web
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Bulat Shakirzyanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-07 00:00:00.000000000 Z
+date: 2014-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta
-  type: :runtime
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: thin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta
-  name: cassandra-driver
-- !ruby/object:Gem::Dependency
+        version: '1.6'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rack-cors
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.6'
-  name: thin
-- !ruby/object:Gem::Dependency
+        version: '0.2'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.2'
-  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rack-parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.2'
-  name: rack-cors
-- !ruby/object:Gem::Dependency
+        version: '0.6'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.6'
-  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.6'
-  name: rack-parser
-- !ruby/object:Gem::Dependency
+        version: '1.4'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.4'
-  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: lz4-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.4'
-  name: sinatra
-- !ruby/object:Gem::Dependency
+        version: '0.3'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
-  name: bundler
-- !ruby/object:Gem::Dependency
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
-  requirement: !ruby/object:Gem::Requirement
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
-  name: rake
 description: Apache Cassandra web interface using Ruby, Event-machine, AngularJS,
   Server-Sent-Events and DataStax Ruby driver for Apache Cassandra
 email:
@@ -119,6 +133,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - app.rb
+- app/helpers/async.rb
 - app/helpers/json.rb
 - app/helpers/sse.rb
 - app/public/css/bootstrap-theme.css
@@ -156,17 +171,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: A simple web ui for Apache Cassandra