ibm_sbdtc_rest 0.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Ruan
+
+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.rdoc

@@ -0,0 +1,18 @@
+= ibm_sbdtc_rest
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 David Ruan. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ibm_sbdtc_rest"
+    gem.summary = %Q{isbdtc rest api client}
+    gem.description = %Q{isbdtc rest api client}
+    gem.email = "ruanwz@gmail.com"
+    gem.homepage = "http://github.com/ruanwz/ibm_sbdtc_rest"
+    gem.authors = ["David Ruan"]
+    gem.add_development_dependency "rspec", ">=1.2.9"
+    gem.add_development_dependency "cucumber", ">= 0"
+    gem.add_development_dependency "jeweler", ">= 1.4.0"
+		gem.add_dependency "thor", ">=0.11.8"
+		gem.add_dependency "json", ">=1.1.9"
+		gem.add_dependency "rest-client", ">=1.0.4"
+		gem.files = FileList['lib/**/*.rb', 'bin/*', '[A-Z]*', 'test/**/*'].to_a
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ibm_sbdtc_rest #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/ibmcloud_admin

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+begin
+  if RUBY_VERSION <= '1.8.6'
+    require 'ruby-debug'
+  end
+rescue LoadError
+end
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'ibm_sbdtc_rest'
+require 'pp'
+
+class IbmCloudAdmin < Thor
+  map "-h" => :help
+  map "-li" => :list_instances
+  map "-v" => :version
+  map "--list_instances" => :list_instances
+
+  desc 'list_instances', "list the current instances of IbmCloudAdmin"
+  def list_instances
+		server = IbmCloudRest.new
+		puts JSON.pretty_generate(server.instances)
+  end
+
+  desc 'version', "the current version of IbmCloudAdmin"
+  def version
+    version_file = File.dirname(__FILE__) + '/../VERSION'
+    if File.exists?(version_file) and version = File.read(version_file)
+      puts "IbmCloudAdmin version: #{version}"
+    end
+  end
+
+  desc 'help', 'help output'
+  def help
+    puts %{
+      Usage: #{$0} /path/to/your/app [options]
+
+      Options:
+      -g, --generate                   Run the generate command to build a project
+      -li, --list_instances            List all instances
+      -j, --just_recipe                Run the just_recipe command to only run specified recipes, templates, etc.
+      -d, --display                    Instead of running, show the template or recipe body
+      -r, --recipes                    Recipes to use
+      -s, --save                       Save current set of options
+      -u, --use                        Use a saved set of options
+      --gems                           Gems to include
+
+      IbmCloudAdmin Info:
+      -v, --version                    Show the IbmCloudAdmin version number and quit.
+      -l, --list                       Show the various recipes known to IbmCloudAdmin and quit.
+      -h, --help                       Show this help message and quit.
+
+      General Options:
+
+      Description:
+      IbmCloudAdmin is used for Ibm Cloud Service.
+
+      Example:
+    } 
+  end
+end
+def method_missing(*args)
+  unless @activesupport_required
+    require 'activesupport'
+    @activesupport_required = true
+    m = args.shift
+    send(m, *args)
+  else
+    super
+  end
+end
+
+IbmCloudAdmin.start
+

data/lib/ibm_cloud_rest/core/adapters/restclient.rb

@@ -0,0 +1,45 @@
+module RestClientAdapter
+   
+  module API
+		def read_config
+			if File.exists? File.expand_path('~/.isbdtcrc')
+				return YAML.load(File.new(File.expand_path('~/.isbdtcrc')))
+			else
+        raise "Error while read config file"
+			end
+		end
+    def proxy=(url)
+      RestClient.proxy = url
+    end 
+    
+    def proxy
+      RestClient.proxy
+    end
+
+    def get(uri, headers={:accept => 'application/json'})
+      #RestClient.get(uri, headers)
+			config = read_config
+			rest_get=RestClient::Request.new(:method => :get, :url => uri, :headers => headers,:user => config['user'], :password => config['password'])
+			rest_get.execute
+    end
+  
+    def post(uri, payload, headers={:accept => 'application/json'})
+      RestClient.post(uri, payload, headers)
+    end
+  
+    def put(uri, payload, headers={:accept => 'application/json'})
+      RestClient.put(uri, payload, headers)
+    end
+  
+    def delete(uri, headers={:accept => 'application/json'})
+      RestClient.delete(uri, headers)
+    end
+  
+    def copy(uri, headers)
+      RestClient::Request.execute(  :method   => :copy,
+                                    :url      => uri,
+                                    :headers  => headers) 
+    end
+  end 
+  
+end

data/lib/ibm_cloud_rest/core/database.rb

@@ -0,0 +1,328 @@
+require 'cgi'
+require "base64"
+
+module IbmCloudRest
+  class Database
+    attr_reader :server, :host, :name, :root, :uri
+    attr_accessor :bulk_save_cache_limit
+     
+    # Create a IbmCloudRest::Database adapter for the supplied IbmCloudRest::Server
+    # and database name.
+    #  
+    # ==== Parameters
+    # server<IbmCloudRest::Server>:: database host
+    # name<String>:: database name
+    #
+    def initialize(server, name)
+      @name = name
+      @server = server
+      @host = server.uri
+      @uri  = "/#{name.gsub('/','%2F')}"
+      @root = host + uri
+      @streamer = Streamer.new(self)
+      @bulk_save_cache = []
+      @bulk_save_cache_limit = 500  # must be smaller than the uuid count
+    end
+    
+    # returns the database's uri
+    def to_s
+      @root
+    end
+    
+    # GET the database info from CouchDB
+    def info
+      IbmCloudRest.get @root
+    end
+    
+    # Query the <tt>_all_docs</tt> view. Accepts all the same arguments as view.
+    def documents(params = {})
+      keys = params.delete(:keys)
+      url = IbmCloudRest.paramify_url "#{@root}/_all_docs", params
+      if keys
+        IbmCloudRest.post(url, {:keys => keys})
+      else
+        IbmCloudRest.get url
+      end
+    end
+  
+    # load a set of documents by passing an array of ids
+    def get_bulk(ids)
+      documents(:keys => ids, :include_docs => true)
+    end
+    alias :bulk_load :get_bulk
+  
+    # POST a temporary view function to CouchDB for querying. This is not
+    # recommended, as you don't get any performance benefit from CouchDB's
+    # materialized views. Can be quite slow on large databases.
+    def slow_view(funcs, params = {})
+      keys = params.delete(:keys)
+      funcs = funcs.merge({:keys => keys}) if keys
+      url = IbmCloudRest.paramify_url "#{@root}/_temp_view", params
+      JSON.parse(HttpAbstraction.post(url, funcs.to_json, {"Content-Type" => 'application/json'}))
+    end
+    
+    # backwards compatibility is a plus
+    alias :temp_view :slow_view
+  
+    # Query a CouchDB view as defined by a <tt>_design</tt> document. Accepts
+    # paramaters as described in http://wiki.apache.org/couchdb/HttpViewApi
+    def view(name, params = {}, &block)
+      keys = params.delete(:keys)
+      name = name.split('/') # I think this will always be length == 2, but maybe not...
+      dname = name.shift
+      vname = name.join('/')
+      url = IbmCloudRest.paramify_url "#{@root}/_design/#{dname}/_view/#{vname}", params
+      if keys
+        IbmCloudRest.post(url, {:keys => keys})
+      else
+        if block_given?
+          @streamer.view("_design/#{dname}/_view/#{vname}", params, &block)
+        else
+          IbmCloudRest.get url
+        end
+      end
+    end
+    
+    # GET a document from CouchDB, by id. Returns a Ruby Hash.
+    def get(id, params = {})
+      slug = escape_docid(id)
+      url = IbmCloudRest.paramify_url("#{@root}/#{slug}", params)
+      result = IbmCloudRest.get(url)
+      return result unless result.is_a?(Hash)
+      doc = if /^_design/ =~ result["_id"]
+        Design.new(result)
+      else
+        Document.new(result)
+      end
+      doc.database = self
+      doc
+    end
+    
+    # GET an attachment directly from CouchDB
+    def fetch_attachment(doc, name)
+      uri = url_for_attachment(doc, name)
+      HttpAbstraction.get uri
+    end
+    
+    # PUT an attachment directly to CouchDB
+    def put_attachment(doc, name, file, options = {})
+      docid = escape_docid(doc['_id'])
+      name = CGI.escape(name)
+      uri = url_for_attachment(doc, name)
+      JSON.parse(HttpAbstraction.put(uri, file, options))
+    end
+    
+    # DELETE an attachment directly from CouchDB
+    def delete_attachment(doc, name, force=false)
+      uri = url_for_attachment(doc, name)
+      # this needs a rev
+      begin
+        JSON.parse(HttpAbstraction.delete(uri))
+      rescue Exception => error
+        if force
+          # get over a 409
+          doc = get(doc['_id'])
+          uri = url_for_attachment(doc, name)
+          JSON.parse(HttpAbstraction.delete(uri))
+        else
+          error
+        end
+      end
+    end
+    
+    # Save a document to CouchDB. This will use the <tt>_id</tt> field from
+    # the document as the id for PUT, or request a new UUID from CouchDB, if
+    # no <tt>_id</tt> is present on the document. IDs are attached to
+    # documents on the client side because POST has the curious property of
+    # being automatically retried by proxies in the event of network
+    # segmentation and lost responses.
+    #
+    # If <tt>bulk</tt> is true (false by default) the document is cached for bulk-saving later.
+    # Bulk saving happens automatically when #bulk_save_cache limit is exceded, or on the next non bulk save.
+    def save_doc(doc, bulk = false)
+      if doc['_attachments']
+        doc['_attachments'] = encode_attachments(doc['_attachments'])
+      end
+      if bulk
+        @bulk_save_cache << doc
+        return bulk_save if @bulk_save_cache.length >= @bulk_save_cache_limit
+        return {"ok" => true} # Compatibility with Document#save
+      elsif !bulk && @bulk_save_cache.length > 0
+        bulk_save
+      end
+      result = if doc['_id']
+        slug = escape_docid(doc['_id'])
+        begin     
+          IbmCloudRest.put "#{@root}/#{slug}", doc
+        rescue HttpAbstraction::ResourceNotFound
+          p "resource not found when saving even tho an id was passed"
+          slug = doc['_id'] = @server.next_uuid
+          IbmCloudRest.put "#{@root}/#{slug}", doc
+        end
+      else
+        begin
+          slug = doc['_id'] = @server.next_uuid
+          IbmCloudRest.put "#{@root}/#{slug}", doc
+        rescue #old version of couchdb
+          IbmCloudRest.post @root, doc
+        end
+      end
+      if result['ok']
+        doc['_id'] = result['id']
+        doc['_rev'] = result['rev']
+        doc.database = self if doc.respond_to?(:database=)
+      end
+      result
+    end
+    
+    ### DEPRECATION NOTICE
+    def save(doc, bulk=false)
+      puts "IbmCloudRest::Database's save method is being deprecated, please use save_doc instead"
+      save_doc(doc, bulk)
+    end
+    
+    
+    # POST an array of documents to CouchDB. If any of the documents are
+    # missing ids, supply one from the uuid cache.
+    #
+    # If called with no arguments, bulk saves the cache of documents to be bulk saved.
+    def bulk_save(docs = nil, use_uuids = true)
+      if docs.nil?
+        docs = @bulk_save_cache
+        @bulk_save_cache = []
+      end
+      if (use_uuids) 
+        ids, noids = docs.partition{|d|d['_id']}
+        uuid_count = [noids.length, @server.uuid_batch_count].max
+        noids.each do |doc|
+          nextid = @server.next_uuid(uuid_count) rescue nil
+          doc['_id'] = nextid if nextid
+        end
+      end
+      IbmCloudRest.post "#{@root}/_bulk_docs", {:docs => docs}
+    end
+    alias :bulk_delete :bulk_save
+    
+    # DELETE the document from CouchDB that has the given <tt>_id</tt> and
+    # <tt>_rev</tt>.
+    #
+    # If <tt>bulk</tt> is true (false by default) the deletion is recorded for bulk-saving (bulk-deletion :) later.
+    # Bulk saving happens automatically when #bulk_save_cache limit is exceded, or on the next non bulk save.
+    def delete_doc(doc, bulk = false)
+      raise ArgumentError, "_id and _rev required for deleting" unless doc['_id'] && doc['_rev']      
+      if bulk
+        @bulk_save_cache << { '_id' => doc['_id'], '_rev' => doc['_rev'], '_deleted' => true }
+        return bulk_save if @bulk_save_cache.length >= @bulk_save_cache_limit
+        return { "ok" => true } # Mimic the non-deferred version
+      end
+      slug = escape_docid(doc['_id'])        
+      IbmCloudRest.delete "#{@root}/#{slug}?rev=#{doc['_rev']}"
+    end
+    
+    ### DEPRECATION NOTICE
+    def delete(doc, bulk=false)
+      puts "IbmCloudRest::Database's delete method is being deprecated, please use delete_doc instead"
+      delete_doc(doc, bulk)
+    end
+    
+    # COPY an existing document to a new id. If the destination id currently exists, a rev must be provided.
+    # <tt>dest</tt> can take one of two forms if overwriting: "id_to_overwrite?rev=revision" or the actual doc
+    # hash with a '_rev' key
+    def copy_doc(doc, dest)
+      raise ArgumentError, "_id is required for copying" unless doc['_id']
+      slug = escape_docid(doc['_id'])        
+      destination = if dest.respond_to?(:has_key?) && dest['_id'] && dest['_rev']
+        "#{dest['_id']}?rev=#{dest['_rev']}"
+      else
+        dest
+      end
+      IbmCloudRest.copy "#{@root}/#{slug}", destination
+    end
+    
+    ### DEPRECATION NOTICE
+    def copy(doc, dest)
+      puts "IbmCloudRest::Database's copy method is being deprecated, please use copy_doc instead"
+      copy_doc(doc, dest)
+    end
+    
+    # Compact the database, removing old document revisions and optimizing space use.
+    def compact!
+      IbmCloudRest.post "#{@root}/_compact"
+    end
+    
+    # Create the database
+    def create!
+      bool = server.create_db(@name) rescue false
+      bool && true
+    end
+    
+    # Delete and re create the database
+    def recreate!
+      delete!
+      create!
+    rescue HttpAbstraction::ResourceNotFound
+    ensure
+      create!
+    end
+    
+    # Replicates via "pulling" from another database to this database. Makes no attempt to deal with conflicts.
+    def replicate_from other_db
+      raise ArgumentError, "must provide a CouchReset::Database" unless other_db.kind_of?(IbmCloudRest::Database)
+      IbmCloudRest.post "#{@host}/_replicate", :source => other_db.root, :target => name
+    end
+    
+    # Replicates via "pushing" to another database. Makes no attempt to deal with conflicts.
+    def replicate_to other_db
+      raise ArgumentError, "must provide a CouchReset::Database" unless other_db.kind_of?(IbmCloudRest::Database)
+      IbmCloudRest.post "#{@host}/_replicate", :target => other_db.root, :source => name
+    end
+    
+    # DELETE the database itself. This is not undoable and could be rather
+    # catastrophic. Use with care!
+    def delete!
+      clear_extended_doc_fresh_cache
+      IbmCloudRest.delete @root
+    end
+
+    private
+    
+    def clear_extended_doc_fresh_cache
+      ::IbmCloudRest::ExtendedDocument.subclasses.each{|klass| klass.design_doc_fresh = false if klass.respond_to?(:design_doc_fresh=) }
+    end
+
+    def uri_for_attachment(doc, name)
+      if doc.is_a?(String)
+        puts "IbmCloudRest::Database#fetch_attachment will eventually require a doc as the first argument, not a doc.id"
+        docid = doc
+        rev = nil
+      else
+        docid = doc['_id']
+        rev = doc['_rev']
+      end
+      docid = escape_docid(docid)
+      name = CGI.escape(name)
+      rev = "?rev=#{doc['_rev']}" if rev
+      "/#{docid}/#{name}#{rev}"
+    end
+
+    def url_for_attachment(doc, name)
+      @root + uri_for_attachment(doc, name)
+    end
+    
+    def escape_docid id      
+      /^_design\/(.*)/ =~ id ? "_design/#{CGI.escape($1)}" : CGI.escape(id) 
+    end
+
+    def encode_attachments(attachments)
+      attachments.each do |k,v|
+        next if v['stub']
+        v['data'] = base64(v['data'])
+      end
+      attachments
+    end
+
+    def base64(data)
+      Base64.encode64(data).gsub(/\s/,'')
+    end
+  end
+end