strongspace 0.0.3

data/bin/strongspace

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'strongspace'
+require 'strongspace/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Strongspace::Command.run(command, args)
+

data/lib/strongspace/client.rb

@@ -0,0 +1,136 @@
+require 'rest_client'
+require 'uri'
+require 'strongspace/version'
+require 'json/pure' unless {}.respond_to?(:to_json)
+
+# A Ruby class to call the Strongspace REST API.  You might use this if you want to
+# manage your Strongspace apps from within a Ruby program, such as Capistrano.
+#
+# Example:
+#
+#   require 'strongspace'
+#   strongspace = Strongspace::Client.new('me@example.com', 'mypass')
+#
+class Strongspace::Client
+  def self.version
+    Strongspace::VERSION
+  end
+
+  def self.gem_version_string
+    "strongspace-gem/#{version}"
+  end
+
+  attr_accessor :host, :user, :password
+
+  def self.auth(user, password, host='https://www.strongspace.com')
+    client = new(user, password, host)
+    JSON.parse client.get('/api/v1/api_token', :username => user, :password => password).to_s
+  end
+
+  def username
+    self.user.split("/")[0]
+  end
+
+  def initialize(user, password, host='https://www.strongspace.com')
+    @user = user
+    @password = password
+    @host = host
+  end
+
+  def spaces
+    doc = JSON.parse get('/api/v1/spaces')
+  end
+
+  def destroy_space(space_name)
+    doc = JSON.parse delete("/api/v1/spaces/#{escape(space_name)}").to_s
+  end
+
+  def create_space(name, type='normal')
+    doc = JSON.parse post("/api/v1/spaces", :name => name, :type => type)
+  end
+
+  def get_space(space_name)
+    doc = JSON.parse get("/api/v1/spaces/#{escape(space_name)}")
+  end
+
+  def snapshots(space_name)
+    doc = JSON.parse get("/api/v1/spaces/#{escape(space_name)}/snapshots").to_s
+  end
+
+  def destroy_snapshot(space_name, snapshot_name)
+    doc = JSON.parse delete("/api/v1/spaces/#{escape(space_name)}/snapshots/#{escape(snapshot_name)}").to_s
+  end
+
+  def create_snapshot(space_name, snapshot_name)
+    doc = JSON.parse post("/api/v1/spaces/#{escape(space_name)}/snapshots", :name => snapshot_name)
+  end
+
+
+  # Get the list of ssh public keys for the current user.
+  def keys
+    doc = JSON.parse get('/api/v1/ssh_keys')
+  end
+
+  # Add an ssh public key to the current user.
+  def add_key(key)
+    post("/api/v1/ssh_keys", :key => key).to_s
+  end
+
+  # Remove an existing ssh public key from the current user.
+  def remove_key(key_id)
+    delete("/api/v1/ssh_keys/#{key_id}").to_s
+  end
+
+  # Clear all keys on the current user.
+  def remove_all_keys
+    delete("/api/v1/ssh_keys").to_s
+  end
+
+  ##################
+
+  def resource(uri)
+    RestClient.proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    if uri =~ /^https?/
+      RestClient::Resource.new(uri, user, password)
+    elsif host =~ /^https?/
+      RestClient::Resource.new(host, user, password)[uri]
+    end
+  end
+
+  def get(uri, extra_headers={})    # :nodoc:
+    process(:get, uri, extra_headers)
+  end
+
+  def post(uri, payload="", extra_headers={})    # :nodoc:
+    process(:post, uri, extra_headers, payload)
+  end
+
+  def put(uri, payload, extra_headers={})    # :nodoc:
+    process(:put, uri, extra_headers, payload)
+  end
+
+  def delete(uri, extra_headers={})    # :nodoc:
+    process(:delete, uri, extra_headers)
+  end
+
+  def process(method, uri, extra_headers={}, payload=nil)
+    headers  = strongspace_headers.merge(extra_headers)
+    args     = [method, payload, headers].compact
+    response = resource(uri).send(*args)
+  end
+
+  def escape(value)  # :nodoc:
+    escaped = URI.escape(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    escaped.gsub('.', '%2E') # not covered by the previous URI.escape
+  end
+
+  def strongspace_headers   # :nodoc:
+    {
+      'X-Strongspace-API-Version' => '1',
+      'User-Agent'           => self.class.gem_version_string,
+      'X-Ruby-Version'       => RUBY_VERSION,
+      'X-Ruby-Platform'      => RUBY_PLATFORM
+    }
+  end
+
+end

data/lib/strongspace/command.rb

@@ -0,0 +1,85 @@
+require 'strongspace/helpers'
+require 'strongspace/commands/base'
+
+Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }
+
+module Strongspace
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
+
+    extend Strongspace::Helpers
+
+    class << self
+
+      def run(command, args, retries=0)
+        begin
+          run_internal 'auth:reauthorize', args.dup if retries > 0
+          run_internal(command, args.dup)
+        rescue InvalidCommand
+          error "Unknown command. Run 'strongspace help' for usage information."
+        rescue RestClient::Unauthorized
+          if retries < 3
+            STDERR.puts "Authentication failure"
+            run(command, args, retries+1)
+          else
+            error "Authentication failure"
+          end
+        rescue RestClient::ResourceNotFound => e
+          error extract_not_found(e.http_body)
+        rescue RestClient::RequestFailed => e
+          error extract_error(e.http_body) unless e.http_code == 402
+        rescue RestClient::RequestTimeout
+          error "API request timed out. Please try again, or contact support@strongspace.com if this issue persists."
+        rescue CommandFailed => e
+          error e.message
+        rescue Interrupt => e
+          error "\n[canceled]"
+        end
+      end
+
+      def run_internal(command, args, strongspace=nil)
+        klass, method = parse(command)
+        runner = klass.new(args, strongspace)
+        raise InvalidCommand unless runner.respond_to?(method)
+        runner.send(method)
+      end
+
+      def parse(command)
+        parts = command.split(':')
+        case parts.size
+          when 1
+            begin
+              return eval("Strongspace::Command::#{command.capitalize}"), :index
+            rescue NameError, NoMethodError
+              return Strongspace::Command::App, command.to_sym
+            end
+          else
+            begin
+              const = Strongspace::Command
+              command = parts.pop
+              parts.each { |part| const = const.const_get(part.capitalize) }
+              return const, command.to_sym
+            rescue NameError
+              raise InvalidCommand
+            end
+        end
+      end
+
+      def extract_not_found(body)
+        body =~ /^[\w\s]+ not found$/ ? body : "Resource not found"
+      end
+
+      def extract_error(body)
+        msg = parse_error_json(body) || 'Internal server error'
+        msg.split("\n").map { |line| ' !   ' + line }.join("\n")
+      end
+
+      def parse_error_json(body)
+        json = JSON.parse(body.to_s)
+        json['status']
+      rescue JSON::ParserError
+      end
+    end
+  end
+end

data/lib/strongspace/commands/auth.rb

@@ -0,0 +1,143 @@
+module Strongspace::Command
+  class Auth < Base
+    attr_accessor :credentials
+
+    def client
+      @client ||= init_strongspace
+    end
+
+    def init_strongspace
+      client = Strongspace::Client.new(user, password, host)
+      client
+    end
+
+    # just a stub; will raise if not authenticated
+    def check
+      client.spaces
+    end
+
+    def host
+      ENV['STRONGSPACE_HOST'] || 'https://www.strongspace.com'
+    end
+
+    def reauthorize
+      @credentials = ask_for_credentials
+      write_credentials
+    end
+
+    def user    # :nodoc:
+      get_credentials
+      @credentials[0]
+    end
+
+    def password    # :nodoc:
+      get_credentials
+      @credentials[1]
+    end
+
+    def credentials_file
+      "#{home_directory}/.strongspace/credentials"
+    end
+
+    def get_credentials    # :nodoc:
+      return if @credentials
+      unless @credentials = read_credentials
+        @credentials = ask_for_credentials
+        save_credentials
+      end
+      @credentials
+    end
+
+    def read_credentials
+      File.exists?(credentials_file) and File.read(credentials_file).split("\n")
+    end
+
+    def echo_off
+      system "stty -echo"
+    end
+
+    def echo_on
+      system "stty echo"
+    end
+
+    def ask_for_credentials
+      puts "Enter your Strongspace credentials."
+
+      print "Username or Email: "
+      user = ask
+
+      print "Password: "
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+
+      ["#{user}/token", Strongspace::Client.auth(user, password, host)['api_token']]
+    end
+
+    def ask_for_password_on_windows
+      require "Win32API"
+      char = nil
+      password = ''
+
+      while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+        break if char == 10 || char == 13 # received carriage return or newline
+        if char == 127 || char == 8 # backspace and delete
+          password.slice!(-1, 1)
+        else
+          # windows might throw a -1 at us so make sure to handle RangeError
+          (password << char.chr) rescue RangeError
+        end
+      end
+      puts
+      return password
+    end
+
+    def ask_for_password
+      echo_off
+      password = ask
+      puts
+      echo_on
+      return password
+    end
+
+    def save_credentials
+      begin
+        write_credentials
+        command = 'auth:check'
+        Strongspace::Command.run_internal(command, args)
+      rescue RestClient::Unauthorized => e
+        delete_credentials
+        raise e unless retry_login?
+
+        display "\nAuthentication failed"
+        @credentials = ask_for_credentials
+        @client = init_strongspace
+        retry
+      rescue Exception => e
+        delete_credentials
+        raise e
+      end
+    end
+
+    def retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+
+    def write_credentials
+      FileUtils.mkdir_p(File.dirname(credentials_file))
+      File.open(credentials_file, 'w') do |f|
+        f.puts self.credentials
+      end
+      set_credentials_permissions
+    end
+
+    def set_credentials_permissions
+      FileUtils.chmod 0700, File.dirname(credentials_file)
+      FileUtils.chmod 0600, credentials_file
+    end
+
+    def delete_credentials
+      FileUtils.rm_f(credentials_file)
+    end
+  end
+end

data/lib/strongspace/commands/base.rb

@@ -0,0 +1,16 @@
+module Strongspace::Command
+  class Base
+    include Strongspace::Helpers
+    attr_accessor :args
+    def initialize(args, strongspace=nil)
+      @args = args
+      @strongspace = strongspace
+    end
+
+    def strongspace
+      @strongspace ||= Strongspace::Command.run_internal('auth:client', args)
+    end
+
+  end
+
+end

data/lib/strongspace/commands/help.rb

@@ -0,0 +1,84 @@
+module Strongspace::Command
+  class Help < Base
+    class HelpGroup < Array
+      attr_reader :title
+
+      def initialize(title)
+        @title = title
+      end
+
+      def command(name, description)
+        self << [name, description]
+      end
+
+      def space
+        self << ['', '']
+      end
+    end
+
+    def self.groups
+      @groups ||= []
+    end
+
+    def self.group(title, &block)
+      groups << begin
+        group = HelpGroup.new(title)
+        yield group
+        group
+      end
+    end
+
+    def self.create_default_groups!
+      group 'General Commands' do |group|
+        group.command 'help',                         'show this usage'
+        group.command 'version',                      'show the gem version'
+        group.space
+        group.space
+        group.command 'keys',                         'show your user\'s public keys'
+        group.command 'keys:add [<path to keyfile>]', 'add a public key'
+        group.command 'keys:remove <id> ',            'remove a key by id'
+        group.command 'keys:clear',                   'remove all keys'
+        group.space
+        group.space
+        group.command 'spaces',                        'show your user\'s spaces'
+        group.command 'spaces:create <space_name> [type]',        'add a new space. type => (normal,public,backup)'
+        group.command 'spaces:destroy <space_name> [type]',       'remove a space by and destroy its data'
+        group.command 'spaces:snapshots <space_name>',                        'show a space\'s snapshots'
+        group.command 'spaces:create_snapshot <space_name@snapshot_name>',            'take a space of a space.'
+        group.command 'spaces:destroy_snapshot <space_name@snapshot_name>',         'remove a snapshot from a space'
+      end
+    end
+
+    def index
+      display usage
+    end
+
+    def version
+      display Strongspace::Client.version
+    end
+
+    def usage
+      longest_command_length = self.class.groups.map do |group|
+        group.map { |g| g.first.length }
+      end.flatten.max
+
+      self.class.groups.inject(StringIO.new) do |output, group|
+        output.puts "=== %s" % group.title
+        output.puts
+
+        group.each do |command, description|
+          if command.empty?
+            output.puts
+          else
+            output.puts "%-*s # %s" % [longest_command_length, command, description]
+          end
+        end
+
+        output.puts
+        output
+      end.string
+    end
+  end
+end
+
+Strongspace::Command::Help.create_default_groups!

data/lib/strongspace/commands/keys.rb

@@ -0,0 +1,50 @@
+module Strongspace::Command
+  class Keys < Base
+    def list
+      long = args.any? { |a| a == '--long' }
+      keys = strongspace.keys["ssh_keys"]
+      if keys.empty?
+        display "No keys for #{strongspace.username}"
+      else
+        display "=== #{keys.size} key#{'s' if keys.size > 1} for #{strongspace.username}"
+        keys.each do |key|
+          display long ? key["key"].strip : format_key_for_display(key["key"]) + "    key-id: #{key["id"]}"
+        end
+      end
+    end
+    alias :index :list
+
+    def add
+      keyfile = args.first || find_key
+      key = File.read(keyfile)
+
+      display "Uploading ssh public key #{keyfile}"
+
+      strongspace.add_key(key)
+    end
+
+    def remove
+      strongspace.remove_key(args.first)
+      display "Key #{args.first} removed."
+    end
+
+    def clear
+      strongspace.remove_all_keys
+      display "All keys removed."
+    end
+
+    protected
+      def find_key
+        %w(rsa dsa).each do |key_type|
+          keyfile = "#{home_directory}/.ssh/id_#{key_type}.pub"
+          return keyfile if File.exists? keyfile
+        end
+        raise CommandFailed, "No ssh public key found in #{home_directory}/.ssh/id_[rd]sa.pub.  You may want to specify the full path to the keyfile."
+      end
+
+      def format_key_for_display(key)
+        type, hex, local = key.strip.split(/\s/)
+        [type, hex[0,10] + '...' + hex[-10,10], local].join(' ')
+      end
+  end
+end

data/lib/strongspace/commands/spaces.rb

@@ -0,0 +1,65 @@
+module Strongspace::Command
+  class Spaces < Base
+    def list
+      long = args.any? { |a| a == '--long' }
+      spaces = strongspace.spaces["spaces"]
+
+      if spaces.empty?
+        display "#{strongspace.username} has no spaces"
+      else
+        display "=== #{strongspace.username} has #{spaces.size} space#{'s' if spaces.size > 1}"
+        spaces.each do |space|
+          space = space["space"]
+          display "#{space['name']} [type: #{space['type']}, snapshots: #{space['snapshots']}]"
+        end
+      end
+    end
+    alias :index :list
+
+    def create
+      name = args[0]
+      type = args[1]
+
+      strongspace.create_space(name, type)
+      display "Create space #{name}"
+    end
+
+    def destroy
+      strongspace.destroy_space(args.first)
+      display "Space #{args.first} removed."
+    end
+
+    def snapshots
+      if args.length == 0
+        display "No space specified."
+        return
+      end
+      snapshots = strongspace.snapshots(args.first)["snapshots"]
+
+      if snapshots.empty?
+        display "Space #{args.first} has no snapshots"
+      else
+        display "=== Space #{args.first} has #{snapshots.size} snapshot#{'s' if snapshots.size > 1}"
+        snapshots.each do |snapshot|
+          snapshot = snapshot["snapshot"]
+          display "#{args.first}@#{snapshot['name']} [created: #{snapshot['created_at']}]"
+        end
+      end
+    end
+
+    def create_snapshot
+      space_name, snapshot_name = args[0].split("@")
+
+      strongspace.create_snapshot(space_name, snapshot_name)
+      display "Created snapshot '#{args[0]}'"
+    end
+
+    def destroy_snapshot
+      space_name, snapshot_name = args[0].split("@")
+
+      strongspace.destroy_snapshot(space_name, snapshot_name)
+      display "Destroyed snapshot '#{args.first}'"
+    end
+
+  end
+end

data/lib/strongspace/commands/version.rb

@@ -0,0 +1,7 @@
+module Strongspace::Command
+  class Version < Base
+    def index
+      display Strongspace::Client.gem_version_string
+    end
+  end
+end

data/lib/strongspace/helpers.rb

@@ -0,0 +1,86 @@
+module Strongspace
+  module Helpers
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def running_on_a_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+
+    def display(msg, newline=true)
+      if newline
+        puts(msg)
+      else
+        print(msg)
+        STDOUT.flush
+      end
+    end
+
+    def redisplay(line, line_break = false)
+      display("\r\e[0K#{line}", line_break)
+    end
+
+    def error(msg)
+      STDERR.puts(msg)
+      exit 1
+    end
+
+    def confirm(message="Are you sure you wish to continue? (y/n)?")
+      display("#{message} ", false)
+      ask.downcase == 'y'
+    end
+
+    def confirm_command(app = app)
+      if extract_option('--force')
+        display("Warning: The --force switch is deprecated, and will be removed in a future release. Use --confirm #{app} instead.")
+        return true
+      end
+
+      raise(Strongspace::Command::CommandFailed, "No app specified.\nRun this command from app folder or set it adding --app <app name>") unless app
+
+      confirmed_app = extract_option('--confirm', false)
+      if confirmed_app
+        unless confirmed_app == app
+          raise(Strongspace::Command::CommandFailed, "Confirmed app #{confirmed_app} did not match the selected app #{app}.")
+        end
+        return true
+      else
+        display "\n !    Potentially Destructive Action"
+        display " !    To proceed, type \"#{app}\" or re-run this command with --confirm #{@app}"
+        display "> ", false
+        if ask.downcase != app
+          display " !    Input did not match #{app}. Aborted."
+          false
+        else
+          true
+        end
+      end
+    end
+
+    def format_date(date)
+      date = Time.parse(date) if date.is_a?(String)
+      date.strftime("%Y-%m-%d %H:%M %Z")
+    end
+
+    def ask
+      gets.strip
+    end
+
+    def shell(cmd)
+      FileUtils.cd(Dir.pwd) {|d| return `#{cmd}`}
+    end
+  end
+end
+
+unless String.method_defined?(:shellescape)
+  class String
+    def shellescape
+      empty? ? "''" : gsub(/([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\\\\1').gsub(/\n/, "'\n'")
+    end
+  end
+end

data/lib/strongspace/version.rb

@@ -0,0 +1,3 @@
+module Strongspace
+  VERSION = "0.0.3"
+end

data/lib/strongspace.rb

@@ -0,0 +1,3 @@
+module Strongspace; end
+
+require 'strongspace/client'

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification 
+name: strongspace
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Strongspace
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-06 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: taps
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 3
+        - 11
+        version: 0.3.11
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 7
+        - 0
+        version: 1.7.0
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :runtime
+  version_requirements: *id006
+description: Client library and command line tool for Strongspace.
+email: support@strongspace.com
+executables: 
+- strongspace
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/strongspace
+- lib/strongspace/client.rb
+- lib/strongspace/command.rb
+- lib/strongspace/commands/auth.rb
+- lib/strongspace/commands/base.rb
+- lib/strongspace/commands/help.rb
+- lib/strongspace/commands/keys.rb
+- lib/strongspace/commands/spaces.rb
+- lib/strongspace/commands/version.rb
+- lib/strongspace/helpers.rb
+- lib/strongspace/version.rb
+- lib/strongspace.rb
+has_rdoc: true
+homepage: http://github.com/expandrive/strongspace
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Client library and CLI for Strongspace.
+test_files: []
+