mode 0.0.10 → 0.0.11

data/lib/mode/commands/login.rb

@@ -23,8 +23,8 @@ module Mode
 
         def execute
           username, password = configure_credentials
-          chosen_token       = choose_access_token.token
-          update_configuration(environment, username, chosen_token)
+          access_token       = choose_access_token
+          update_configuration(environment, username, access_token)
         rescue => err
           say err.message
           Mode::Logger.instance.error(
@@ -36,9 +36,9 @@ module Mode
 
       def configure_api(username, password)
         Mode::API::Request.configure(environment, {
-          :credentials => {
-            :username => username,
-            :access_token => password
+          'credentials' => {
+            'username' => username,
+            'password' => password
           }
         })
       end
@@ -54,13 +54,9 @@ module Mode
         return username, password
       end
 
-      def fetch_access_tokens
-        resource = Mode::API::Request.get(:access_tokens)
-
+      def verify_resource(resource)
         if resource.is_a?(Mode::API::Resource)
-          resource.embedded('access_tokens').map do |access_token|
-            Mode::Auth::AccessToken.new(access_token)
-          end
+          resource
         elsif resource.status == 401
           raise "Login failed, credentials invalid"
         elsif resource.status == 404
@@ -72,35 +68,102 @@ module Mode
         end
       end
 
-      def prompt_access_tokens(access_tokens)
-        say "\nPlease choose an access token to use:\n\n"
+      def create_access_token
+        name = ask "\nChoose a token name:"
+
+        resource = Mode::API::Request.post(
+          :access_tokens,
+          :access_token => { :name => name }
+        )
+
+        Mode::Auth::AccessToken.new(verify_resource(resource))
+      end
+
+      def fetch_access_tokens
+        resource = Mode::API::Request.get(:access_tokens)
+        tokens = verify_resource(resource).embedded('access_tokens')
+
+        tokens.map do |access_token|
+          Mode::Auth::AccessToken.new(access_token)
+        end
+      end
+
+      def verify_access_token(access_token, password)
+        if token = access_token.verify(password)
+          token
+        else
+          nil
+        end
+      end
+
+      def prompt_create_access_token
+        if yes? "\nNo API tokens found, would you like to create a new token? [y/n]"
+          create_access_token
+        else
+          raise "No API access tokens found or created"
+        end
+      end
+
+      def verify_access_token_secret(access_token)
+        token = nil
+        until token
+          password = ask "Please provide the access token password:"
+          token = verify_access_token(access_token, password)
+          say "API token verification failed, please try again." unless token
+        end
+        token
+      end
+
+      def ask_for_access_token_choice(access_tokens)
+        say "\nAvailable access tokens\n\n"
+
+        correct_answer = nil
+        until correct_answer
+          answer_set = [""]
+          access_tokens.each_with_index do |token, index|
+            answer_set << "#{index + 1}"
+            say "#{index + 1}. #{token.name}"
+          end
 
-        choices = []
-        access_tokens.each_with_index do |token, index|
-          choices << (index + 1).to_s
-          say "#{index + 1}. #{token.name}"
+          answer = ask "\nPlease choose an API token or [enter] to create a new token:"
+
+          correct_answer = answer_set.include?(answer) ? answer : nil
+          say("Your response must be one of the tokens or [enter]. Please try again.") unless correct_answer
+        end
+        correct_answer
+      end
+
+      def prompt_choose_access_token(access_tokens)
+        choice = ask_for_access_token_choice(access_tokens)
+
+        if choice.length == 0
+          create_access_token
+        else
+          verify_access_token_secret(access_tokens[choice.to_i - 1])
         end
-        choice = ask "\nWhich token would you like to use?:", :limited_to => choices
       end
 
       def choose_access_token
         access_tokens = fetch_access_tokens
 
-        if access_tokens.nil?
-          raise "Couldn't retrieve access tokens"
-        elsif access_tokens.length == 1
-          access_tokens.first
+        if access_tokens.empty?
+          access_token = prompt_create_access_token
         else
-          chosen = prompt_access_tokens(access_tokens)
-          access_tokens[chosen.to_i - 1]
+          access_token = prompt_choose_access_token(access_tokens)
         end
       end
 
       def update_configuration(environment, username, access_token)        
         config = find_or_create_config
+
         config.username     = username
-        config.access_token = access_token
         config.environment  = environment.to_s
+
+        config.access_token = {
+          'token'    => access_token.token,
+          'password' => access_token.password
+        }
+
         config.save
 
         say "Updated configuration at #{config.path}"

data/lib/mode/config.rb

@@ -2,17 +2,69 @@ require 'yaml'
 
 module Mode
   class Config
-    include Mode::Configurable
+    attr_reader :path
 
     # Config Variables
     attr_accessor :username
     attr_accessor :access_token
     attr_accessor :environment
+    attr_accessor :data_sources
+
+    def initialize(path, filename = nil)
+      @path = self.class.full_path(path, filename)
+
+      if File.exist?(@path)
+        configure YAML.load_file(@path)
+      else
+        raise "Could not load configuration file from #{@path}"
+      end
+    end
+
+    def save
+      File.open(path, 'w+') do |file|
+        file.write(to_yaml)
+      end
+    end
+
+    def access_token_key
+      access_token && access_token['token']
+    end
+
+    def access_token_password
+      access_token && access_token['password']
+    end
 
     class << self
       def default_filename
         'config.yml'
       end
+
+      def exists?(path)
+        File.exist?(full_path(path))
+      end
+
+      def init(path, filename = nil)
+        FileUtils.mkdir_p(default_dir)
+        FileUtils.mkdir_p(drivers_dir)
+        
+        File.open(full_path(path, filename), 'w+') do |file|
+          file.write({}.to_yaml)
+        end
+
+        new(path, filename)
+      end
+
+      def default_dir
+        File.expand_path("~/.mode")
+      end
+
+      def drivers_dir
+        File.join(default_dir, 'drivers')
+      end
+
+      def full_path(path, filename = nil)
+        File.expand_path(File.join(path, filename || default_filename))
+      end
     end
 
     private
@@ -21,13 +73,19 @@ module Mode
       @username = config['username']
       @access_token = config['access_token']
       @environment = config['environment'].to_s
+
+      @data_sources ||= []
+      (config['data_sources'] || []).each do |name, props|
+        data_sources << Mode::Connector::DataSource.new(name, props)
+      end
     end
 
     def to_yaml
       {
         'username' => username,
         'access_token' => access_token,
-        'environment' => environment
+        'environment' => environment,
+        'data_sources' => data_sources
       }.to_yaml
     end
   end

data/lib/mode/connector/connect.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'mode'
+
+runner = Mode::Connector::Runner.new(:max_jobs => ARGV[0] || 4)
+
+trap("INT")  { runner.stop }
+trap("HUP")  { runner.stop }
+trap("TERM") { runner.stop }
+
+runner.start

data/lib/mode/connector/daemon.rb

@@ -1,26 +1,68 @@
-require 'daemon_spawn'
-
 module Mode
   module Connector
-    class Daemon < DaemonSpawn::Base
+    class Daemon
+      attr_reader :max_jobs
       attr_reader :scheduler
 
-      def start(args)
-        max_jobs = args.shift
-        data_sources = args.shift
-
-        @scheduler = Mode::Connector::Scheduler.new(
-          data_sources, :max_jobs => max_jobs
-        )
+      def initialize(options = {})
+        @max_jobs = options[:max_jobs].to_i || 4
+      end
 
-        @scheduler.start!
+      def start        
+        load_drivers
+        configure_api
+        scheduler.start!
       rescue => err
         Mode::Logger.instance.error(
-          "Connector::Daemon", err.message, err.backtrace)
+          "Connector::Runner", err.message, err.backtrace)
       end
 
       def stop
         scheduler.stop!
+      rescue => err
+        Mode::Logger.instance.error(
+          "Connector::Runner", err.message, err.backtrace)
+      end
+
+      private
+
+      def scheduler
+        @scheduler ||= Mode::Connector::Scheduler.new(
+          data_sources, :max_jobs => max_jobs
+        )
+      end
+
+      def load_drivers
+        Dir[File.join(drivers_dir, '*.jar')].each do |driver|
+          load driver
+        end if RUBY_PLATFORM == 'java'
+      end
+
+      def configure_api
+        Mode::API::Request.configure(
+          config.environment, {
+            'credentials' => {
+              'username' => config.username,
+              'password' => config.access_token_password
+            }, 'access_token' => config.access_token
+          }
+        )
+      end
+
+      def data_sources
+        config.data_sources
+      end
+
+      def config_dir
+        Mode::Config.default_dir
+      end
+
+      def drivers_dir
+        File.join(config_dir, 'drivers')
+      end
+
+      def config
+        @config ||= Mode::Config.new(config_dir)
       end
     end
   end

data/lib/mode/connector/daemonizer.rb

@@ -0,0 +1,107 @@
+require 'spoon'
+require 'timeout'
+
+module Mode
+  module Connector
+    class Daemonizer
+      attr_reader :args
+      attr_reader :timeout
+      attr_reader :pid_file
+      attr_reader :executable
+
+      def initialize(options = {})
+        @args = options[:args] || []
+        @timeout = options[:timeout] || 10
+        @pid_file = options[:pid_file] || default_pid_file
+        @executable = options[:executable] || default_executable
+      end
+
+      def alive?
+        return false unless pid
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, TypeError # PID is NOT running or is zombied
+        false
+      rescue Errno::EPERM
+        STDERR.puts "Permission denied for process #{pid}!";
+        false
+      end
+
+      def restart
+        begin
+          stop
+        ensure
+          start
+        end
+      end
+
+      def start
+        abort "Mode connector already running" if alive?
+        abort "Insufficient permissions to start Mode connector" unless File.executable?(executable)
+
+        if pid = Spoon.spawnp(executable, *args.collect(&:to_s))
+          create_pid(pid)
+          STDOUT.puts "Mode connector running with pid #{pid}"
+        else
+          Process.setsid
+        end
+      end
+
+      def stop
+        abort "Mode connector not running, nothing to stop" unless alive?
+
+        begin
+          STDOUT.puts "Stopping process #{pid}..."
+
+          Timeout.timeout(timeout) do
+            Process.kill("TERM", pid)
+            sleep 1 while alive?
+          end
+        rescue Timeout::Error
+          STDERR.puts "Graceful shutdown timeout, sending KILL signal"
+          Process.kill("KILL", pid)
+          sleep 0.1 while alive?
+        end
+
+        remove_pid
+        STDOUT.puts "Mode connector stopped."
+      end
+
+      private
+
+      def pid
+        @pid ||= File.read(pid_file).gsub(/[^0-9]/,'').to_i
+      rescue Errno::ENOENT => e
+        nil
+      end
+
+      def remove_pid
+        File.unlink(pid_file)
+      rescue => e
+        STDERR.puts "ERROR: Unable to unlink #{pid_file}:\n\t" +
+          "(#{e.class}) #{e.message}"
+        exit
+      end
+
+      def create_pid(pid)
+        File.open(pid_file, 'w') { |f| f.puts pid }
+      rescue => e
+        STDERR.puts "Error: Unable to open #{pid_file} for writing:\n\t" +
+            "(#{e.class}) #{e.message}"
+        exit!
+      end
+
+      def default_pid_file
+        File.join(Mode::Config.default_dir, 'connect.pid')
+      end
+
+      def default_lib_path
+        File.join(File.dirname(__FILE__), '..', '..')
+      end
+
+      def default_executable
+        File.expand_path(File.join(default_lib_path, 'connect.rb'))
+      end
+    end
+  end
+end

data/lib/mode/connector/data_source.rb

@@ -43,21 +43,28 @@ module Mode
       end
 
       def select(query, &block)
-        connection_dataset(query).each(&block)
+        log_connection_query(query)
+        connection.dataset.fetch_rows(query, &block)
       end
 
       def connection
-        @connection ||= Sequel.connect(connection_url, adapter_opts)
+        @connection ||= Sequel.connect(connection_url, adapter_opts).tap do |conn|
+          conn.extension(:connection_validator)
+        end
       end
 
-      def redshift?
-        adapter == 'redshift'
+      def jdbc?
+        adapter.start_with?('jdbc')
       end
 
       def postgres?
         adapter == 'postgres'
       end
 
+      def redshift?
+        ['redshift', 'jdbc:redshift'].include?(adapter)
+      end
+
       private
 
       def adapter_opts
@@ -77,25 +84,45 @@ module Mode
         opts
       end
 
+      def adapter_segment
+        case adapter
+        when 'jdbc:redshift'
+          'jdbc:postgresql'
+        else
+          adapter
+        end
+      end
+
       def port_segment
         port.nil? ? nil : ":#{port}"
       end
 
       def password_segment
+        jdbc? ? jdbc_password_segment : standard_password_segment
+      end
+
+      def jdbc_password_segment
+        password.nil? ? nil : "&password=#{password}"
+      end
+
+      def standard_password_segment
         password.nil? ? nil : ":#{password}"
       end
 
       def connection_url
-        "#{adapter}://#{username}#{password_segment}@#{host}#{port_segment}/#{database}"        
+        jdbc? ? jdbc_connection_url : standard_connection_url
       end
 
-      def connection_dataset(query)
-        log_connection_query(query)
-        connection.dataset.with_sql(query)
-        # figure out how to make cursors work here
+      def jdbc_connection_url
+        "#{adapter_segment}://#{host}#{port_segment}/#{database}?user=#{username}#{password_segment}"
+      end
+
+      def standard_connection_url
+        "#{adapter_segment}://#{username}#{password_segment}@#{host}#{port_segment}/#{database}"
       end
 
       def log_connection_query(query)
+        return if query.nil?
         Mode::Logger.instance.debug(
           "Connect::DataSource", "QUERY", query.split("\n"))
       end