em-riak 0.2.0 → 0.2.5

data/lib/em-riak/basic.rb

@@ -7,319 +7,367 @@ require 'httpi'
 require 'yajl'
 
 module EmRiak
-	attr_accessor :bucket, :interface, :adapter, :hosts, :cluster, :async, :http_client, :vector_lock, :replication, :debug
-	extend self
-
-	# A easy interface to create connections
-	class Connection
-		def initialize(*opts)
-			if opts && opts.length>0
-				opts=opts.first
-				methods=[:bucket, :interface, :adapter, :hosts, :cluster, :async, :http_client, :vector_lock, :repliaction, :debug]
-				opts.each{|key,opt|  EmRiak.send "#{key}=".to_sym, opt if opt && methods.index(key.to_sym)   }
-			else
-				EmRiak.bucket=RIAKBUCKET
-			end
-			EmRiak.debug=false if EmRiak.debug.nil?
-		end
-		def find; EmRiak.find(self); end
-	end
-
-	# -- CRUD
-	class StorageObject < Hash
-		def find; EmRiak.find(self); end
-		def save; EmRiak.save(self); end
-		def destroy; EmRiak.destroy(self); end
-		def add_tag(*args); EmRiak::SecondaryIndex.add_tag(self,args); end
-		def remove_tag(*args); EmRiak::SecondaryIndex.remove_tag(self,args); end
-		def save_as_key(); EmRiak::Grapher.save_object_as_key_name(self) ; end
-		def method_missing(name,*args)
-		    return self[name] if key? name
-		  	if name.to_s.index("=")
-		  		sym_name=name.to_s.gsub("=","").to_sym
-		  		self[sym_name]=args.first
-		  	else
-			    self.each { |k,v| return v if k.to_s.to_sym == name }
-			    super.method_missing name
-			end
-		end
-	end
-	def create(key,*opts)
-		data={:body=>{}}
-		data[:head], data[:query] = handle_options("save",opts)
-		opts.first.each{|key,value| data[:body][key]=value}  if opts && opts.count>0		
-
-		url="/buckets/#{bucket}/keys/#{key_handler(key)}"
-		http("put",key,url,data)
-	end
-	def find(key,*opts)
-		data={}; link=""
-		data[:head], data[:query] = handle_options("get",opts)
-		if data[:head][:link]
-			link=data[:head][:link]
-			data[:head].reject!{|o| o==:link}
-		end
-		
-	  	url="/buckets/#{bucket}/keys/#{key_handler(key)}#{link}"
-	  	http("get",key,url,data)
-	end
-	def save(obj,*opts)
-		data={:body=>{}}
-		obj.each{|key,value| data[:body][key]=value }
-		data[:head], data[:query] = handle_options("save",opts)
-		
-	  	url="/buckets/#{bucket}/keys/#{obj[:riak_key]}"
-	  	http("put",obj[:riak_key],url,data)
-	end
-	def destroy(key,*opts)
-		data={}
-		obj_key=defined?(obj) ? obj[:riak_key] :  (key.class==String ? key : key[:riak_key])
-		data[:head], data[:query] = handle_options("delete",opts)
-
-	  	url="/buckets/#{bucket}/keys/#{key_handler(obj_key)}"
-	  	http("put",obj_key,url,data)
-	  	key=nil
-	end
-
-	# -- Search
-	def search(*args)
-		return "you must provide search mode" if !SEARCH_SUPPORT.index(args[0])
-
-		method=args[0]
-		collect_data=if args[1].class==Hash
-						opts=args[1]
-						args[2..args.count]
-					else
-						args[1..args.count]
-					end
-
-		return "you must provide some vars to do search, for example, bucket name, bin name..." if !defined?(opts) && method!=:map_reduce || opts[:bin].nil? && method==:secondary_index
-
-		case method
-		when :secondary_index
-			bin=opts[:bin].to_s.index("_bin") ? opts[:bin] : "#{opts[:bin]}_bin"
-			mapper_key=collect_data.count>1 ? :secondary_index_multiple_query : :secondary_index_single_query
-
-			members={}
-			EmRiak::MapReduce.submit(mapper_key,{'bucket'=>opts[:bucket],'index'=>bin,'value'=>collect_data.join(',')}).each do |object| 
-				if object[1]["body"] 
-				 	members[object[0].to_sym]=object[1]["body"]
-				else 
-					members[object[0].to_sym]=[] if !members[object[0].to_sym]
-				 	members[object[0].to_sym] << object[1]
-				end if object[0]!=false
-			end
-			members
-		when :full_text # TODO : full-text search is still under implement...
-			[]
-		when :map_reduce
-			EmRiak::MapReduce.submit(collect_data[0])
-		end
-	end
-
-	def http(method,key,url,data,res=nil)		
-		self.async && ["delete","put","post"].index(method) && key!="mapred" ? em_http(method,key,url,data) : open_http(method,key,url,data)
-	end
-	def return_body_handler(string,hash_container,handle_type,handle_type_split_mapper={"hash"=>":","string"=>"=","common"=>","})
-		hash_container={} if !hash_container
-		
-		string=string.gsub("{","").gsub("}","") if handle_type!="hash"
-		split_by= hash_container.class==EmRiak::StorageObject ? "&" : ","
-		string.split(split_by).each do |vars|
-			key,value=vars.split(handle_type_split_mapper[handle_type])
-			value=return_body_handler(value,nil,"hash") if value && value.index("{")
-			value=json_decode("{#{value}}") if value && value.index(":") && value.index(",")
-			hash_container[key.to_sym]=value if value
-		end
-		hash_container
-	end
-
-	def open_http(method,key,url,data,res={})
-		has_http_instance?
-		data={:body=>{},:head=>{},:query=>{}} if !data
-
-		http_client.url     = generate_path(url)
-		http_client.headers = key!="mapred" ? convert_params_layers(data[:head],:to_s) : data[:head]
-		http_client.body    = key!="mapred" ? convert_params_layers(data[:body],:to_s) : data[:body]
-
-		res=HTTPI.request(method.to_sym,http_client)
-		res=res.body if res.class==HTTPI::Response
-
-		res=if !["2i","mapred"].index(key) && res && !["not found\n"].index(res) && ["get","put","post"].index(method)
-				obj=EmRiak::StorageObject.new()
-				if res && res!="not found\n"
-					if res.class==String
-						obj=return_body_handler(URI.unescape(res.force_encoding("UTF-8")).gsub("+"," ").gsub("=>",":"),obj,"string")
-					elsif res.class==Hash
-						res.each{|varkey,value| obj[varkey.to_sym]=value }
-					end
-
-					data.each{|k,v| obj[k]=v } if res.length<1
-					obj[:riak_key]=key if obj.length>0
-				end
-				obj
-			elsif key=="mapred"
-				res
-			else
-				nil
-			end
-		res=nil if res && res.class!=String && res.count<1
-
-		return res
-	end
-
-	def em_http(method,key,url,data)
-		data[:retry]=0 if !data[:retry]
-		begin
-			raise "Retry too much time" if data[:retry]>RETRY_TIMES
-			
-			#conn options
-			conn_options = {
-	          :connect_timeout => EM_REQUEST_TIMEOUT,        # default connection setup timeout
-	          :inactivity_timeout => EM_INACTIVITY_TIMEOUT,    # default connection inactivity (post-setup) timeout
-	      	}
-
-	      	#data[:body]=data[:body] if data[:body].class==Hash && data[:head]['Content-Type'] && data[:head]['Content-Type']=="application/json"
-	      	#request options
-	      	data[:query]="?returnbody=true"
-	      	request_options=data.reject{|k,v| k==:retry}
-
-	      	#do job
-	      	case method
-	      	when "post"
-	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).post request_options	
-	      	when "delete"
-	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).delete request_options	
-	      	when "get"
-	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).get request_options	
-	      	when "put"
-	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).put request_options	
-	      	end
-
-		  	riakHttp.errback{ #Error Callback
-		  		puts "#{method} - #{key} - riak callback error #{riakHttp.response}" if EmRiak.debug
-		  		data[:retry]+=1
-		  		http(method,key,url,data)
-		  	}
-
-		  	#Success Callback
-		  	riakHttp.callback{ puts "#{method} - #{url} - #{key} - riak response #{riakHttp.response}" if EmRiak.debug  }
-		rescue Exception => e
-			puts "em_http - #{method} - #{url} - #{key} error #{e}" if EmRiak.debug
-		end
-
-		# Return Response
-		res=if ["put","post"].index(method)
-			obj=EmRiak::StorageObject.new()
-			data.each{|k,v| obj[k]=v }
-			obj[:riak_key]=key if obj.length>0
-			obj
-		else
-			nil
-		end
-		res
-	end
-
-	def handle_options(action,opts,header={},query="")
-		#Load default header setting
-		case action
-		when "save"
-			header["Content-Type"]="application/json"
-		when "get"
-			header["Content-Type"]="application/json"
-		when "destroy"
-
-		when "add_link"
-			header["Content-Type"]="application/json"
-		when "remove_link"
-		# else
-		# 	header["Content-Type"]="application/json"
-		end
-		
-		if opts && opts.count>0
-			#Map & overwrite if header specisfic
-			opts=opts.first if opts.class==Array
-			opts.each{|k,v|
-				meta=METAMAPPER[k]	
-				if meta
-					header[meta[:key]] = meta[:value] 
-					opts.reject!{true}
-				end
-			}
-
-			# --- Handle the rest headers
-			# Link Walk
-			if opts[:links] && (["save"].index(action))
-				links=[]
-				opts[:links].each{|link| links << %Q[</buckets/#{bucket}/keys/#{link[:target]}>; riaktag="#{link[:tag]}"] }
-				header['Link']= links.join(",")
-			elsif opts[:links] && (["add_link","remove_link"].index(action))
-				links=[]
-				opts[:links].each{|link| links << %Q[</buckets/#{bucket}/keys/#{link[:target]}>; riaktag="#{link[:tag]}"] }
-				header['Link']= links
-			elsif opts[:links] && action=="get"
-				header["Content-Type"]="multipart/mixed"
-				header["Accept"]="multipart/mixed"
-				header[:link]=""
-				keep=opts[:links][:keep] ? '1' : '0' #keep the result
-				opts[:links][:tag].each{|tag| header[:link]+= "/#{bucket},#{tag},#{keep}" }
-			end
-			# 2i
-			header["x-riak-index-#{opts[:bin].to_s}_bin"]=opts[:secondary_index].join(", ") if opts[:secondary_index]
-
-			# Replication, available configs : w, dw, pw
-			# read more at http://docs.basho.com/riak/latest/references/apis/http/HTTP-Store-Object/
-			replication.each{|key,value| hreader[key.to_s]=value} if replication
-
-			header["Content-Type"]=opts[:content_type] if opts[:content_type]
-			header["X-Riak-Vclock"]=opts[:vlock] if opts[:vlock]
-			header["ETag"]=opts[:etag] if opts[:etag]
-			header["Last-Modified"]=opts[:last_modified] if opts[:last_modified]
-			header["returnbody"]= "true" if !async
-			#header["unique"] = true if async=false
-			query="?returnbody=true"
-			opts[:query].each{|k,v| query+="&#{k}={v}" } if opts[:query]
-		end
-		[header,query]
-	end
-
-	def key_handler(key,map={"["=>"%5B","]"=>"%5D","+"=>"%2B","/"=>"%2F","("=>"%28",")"=>"%29",":"=>"%3A"})
-		# To match the key rule from Basho : If your field contains special characters, such as (‘+’,‘/’,‘[’,‘]’,‘(’,‘)’,‘:’ or space), then either surround the phrase in single quotes, or escape each special character with a backslash.
-		# map.each{|origin,value| key.gsub!(origin,value) }
-		EscapeUtils.escape_url(key.to_s.encode('UTF-8'))
-	end
-
-	def json_encode(obj,times=0)
-		y=Yajl::Encoder.new()
-		y.encode(obj)
-	rescue Exception => e
-		puts "json_encode error : #{e}" if EmRiak.debug
-		nil
-	end
-	def json_decode(obj,times=0)
-		y=Yajl::Parser.new()
-		y.parse(obj)
-	rescue Exception => e
-		puts "json_decode error : #{e}" if EmRiak.debug
-		nil
-	end
-
-	def convert_params_layers(origin,to_type,params={})
-	  origin.each{|key,value|
-	    converted=convert_params_layers(value,to_type) if value.class==Hash
-	    key=key.send(to_type)
-	    params[key]= converted ? converted : value
-	  } if origin
-	  params
-	end
-
-	private
-	def generate_path(url); EmRiak.hosts[rand(EmRiak.hosts.length)]+url; end
-	def has_http_instance?
-		if !EmRiak.http_client
-			HTTPI.log=false
-			HTTPI.adapter=:net_http
-			EmRiak.http_client=HTTPI::Request.new
-		end
-	end
+    attr_accessor :bucket, :interface, :adapter, :hosts, :cluster, :async, :http_client, :vector_lock, :replication, :debug
+    extend self
+
+    # A easy interface to create connections
+    class Connection
+        def initialize(*opts)
+            if opts && opts.length>0
+                opts=opts.first
+                methods=[:bucket, :interface, :adapter, :hosts, :cluster, :async, :http_client, :vector_lock, :repliaction, :debug]
+                opts.each{|key,opt|  EmRiak.send "#{key}=".to_sym, opt if opt && methods.index(key.to_sym)   }
+            else
+                EmRiak.bucket=RIAKBUCKET
+            end
+            EmRiak.debug=false if EmRiak.debug.nil?
+        end
+    end
+
+    # -- CRUD
+    class StorageObject < Hash
+        def save(block=nil); EmRiak.save(self,block); end
+        def destroy(block=nil); EmRiak.destroy(self,block); end
+        def add_tag(*args); EmRiak::SecondaryIndex.add_tag(self,args); end
+        def remove_tag(*args); EmRiak::SecondaryIndex.remove_tag(self,args); end
+        def save_as_key(); EmRiak::Grapher.save_object_as_key_name(self) ; end
+        def method_missing(name,*args)
+            return self[name] if key? name
+            if name.to_s.index("=")
+                sym_name=name.to_s.gsub("=","").to_sym
+                self[sym_name]=args.first
+            else
+                self.each { |k,v| return v if k.to_s.to_sym == name }
+                super.method_missing name
+            end
+        end
+    end
+    def create(key,*opts,&callback)
+        data={:body=>{}}
+        opts.first.each{|key,value| data[:body][key]=value}  if opts && opts.count>0
+        data,callback=handle_callback(key,"save",opts,callback,data)
+
+        url="/buckets/#{bucket}/keys/#{key_handler(key)}"
+        http("put",key,url,data,callback)
+    end
+    def find(key,*opts,&callback)
+        link=""
+        data,callback=handle_callback(key,"get",opts,callback)
+
+        if data[:head][:link]
+            link=data[:head][:link]
+            data[:head].reject!{|o| o==:link}
+        end
+        
+        url="/buckets/#{bucket}/keys/#{key_handler(key)}#{link}"
+        http("get",key,url,data,callback)
+    end
+    def save(obj,*opts,&callback)
+        data={:body=>{}}
+        obj.each{|key,value| data[:body][key]=value }
+        data,callback=handle_callback(obj[:riak_key],"save",opts,callback,data)
+        
+        url="/buckets/#{bucket}/keys/#{obj[:riak_key]}"
+        http("put",obj[:riak_key],url,data,callback)
+    end
+    def destroy(key,*opts,&callback)
+        obj_key=defined?(obj) ? obj[:riak_key] :  (key.class==String ? key : key[:riak_key])
+        data,callback=handle_callback(obj_key,"delete",opts,callback)
+
+        url="/buckets/#{bucket}/keys/#{key_handler(obj_key)}"
+        http("put",obj_key,url,data,callback)
+        key=nil
+    end
+
+    # -- Search
+    def search(method_name,*args,&callback)
+        result_handler=nil
+        response=[]
+        return "you must provide search mode" if !SEARCH_SUPPORT.index(method_name)
+
+        collect_data=   case 
+                        when args[0].class==Hash && args.last.class==Proc
+                            opts=args[0]
+                            callback=args.last
+                            args[1..args.count-2]
+                        when args[0].class==Hash
+                            opts=args[0]
+                            args[1..args.count]
+                        when args.last.class==Proc
+                            callback=args.last
+                            args[0..args.count-2]
+                        else
+                            args[0..args.count]
+                        end
+
+        collect_data=collect_data.first if collect_data.count==1
+
+        return "you must provide some vars to do search, for example, bucket name, bin name..." if !defined?(opts) && method_name!=:map_reduce || opts[:bin].nil? && method_name==:secondary_index
+
+        case method_name
+        when :secondary_index
+            bin=opts[:bin].to_s.index("_bin") ? opts[:bin] : "#{opts[:bin]}_bin"
+            bucket=opts[:bucket] ? opts[:bucket] : EmRiak.bucket
+            mapper_key=collect_data.count>1 ? :secondary_index_multiple_query : :secondary_index_single_query
+
+            result_handler=Proc.new{|map_reduce_results,results|
+                map_reduce_results.each do |object| 
+                    if object[1]["body"] 
+                        results[object[0].to_sym]=object[1]["body"]
+                    else 
+                        results[object[0].to_sym]=[] if !results[object[0].to_sym]
+                        results[object[0].to_sym] << object[1]
+                    end if object[0]!=false
+                end
+            }
+            map_reduce_work=[mapper_key,{'bucket'=>bucket,'index'=>bin,'value'=>collect_data.join(',')},result_handler,callback]
+        when :full_text # TODO : full-text search is still under implement...
+            map_reduce_work=[]
+        end
+
+        response=EmRiak::MapReduce.submit(map_reduce_work) if map_reduce_work.count>0
+        response
+    end
+
+    def http(method,key,url,data,callback=nil,res=nil)
+        (callback || self.async && ["delete","put","post"].index(method) && key!="mapred") ? em_http(method,key,url,data,callback) : open_http(method,key,url,data)
+    end
+    def return_body_handler(string,hash_container,handle_type,handle_type_split_mapper={"hash"=>":","string"=>"=","common"=>","})
+        hash_container={} if !hash_container
+        
+        string=string.gsub("{","").gsub("}","") if handle_type!="hash"
+        split_by= hash_container.class==EmRiak::StorageObject ? "&" : ","
+        string.split(split_by).each do |vars|
+            key,value=vars.split(handle_type_split_mapper[handle_type])
+            value=return_body_handler(value,nil,"hash") if value && value.index("{")
+            value=json_decode("{#{value}}") if value && value.index(":") && value.index(",")
+            hash_container[key.to_sym]=value if value
+        end
+        hash_container
+    end
+
+    def open_http(method,key,url,data,res={})
+        has_http_instance?
+        data={:body=>{},:head=>{},:query=>{}} if !data
+
+        http_client.url     = generate_path(url)
+        http_client.headers = key!="mapred" ? convert_params_layers(data[:head],:to_s) : data[:head]
+        http_client.body    = key!="mapred" ? convert_params_layers(data[:body],:to_s) : data[:body]
+        http_client.open_timeout = 300 # seconds. change it if you need
+        http_client.read_timeout = 300 # seconds. change it if you need
+
+        res=HTTPI.request(method.to_sym,http_client)
+        res=res.body if res.class==HTTPI::Response
+
+        res=handle_response_string_to_object(key,res,method,data)
+
+        res=nil if res && res.class!=String && res.count<1
+
+        return res
+    end
+
+    def handle_response_string_to_object(key,res,method,data)
+        raise "response can't be nil" if !res
+
+        return res if key=="mapred"
+        return nil if ["2i"].index(key)
+
+        raise "data not found" if ["not found\n"].index(res)
+        raise "method is not match" if !["get","put","post"].index(method)
+        raise "data is empty" if method=="get" && res.gsub(" ","").length<1
+
+        obj=EmRiak::StorageObject.new()
+
+        if res && res!="not found\n" && 
+            if res.class==String
+                obj=return_body_handler(URI.unescape(res.force_encoding("UTF-8")).gsub("+"," ").gsub("=>",":"),obj,"string")
+            elsif res.class==Hash
+                res.each{|varkey,value| obj[varkey.to_sym]=value }
+            end
+
+            data.each{|k,v| obj[k]=v } if res.length<1
+            obj[:riak_key]=key if obj.length>0
+        end
+        return obj
+    rescue Exception=>e
+        puts "handle response error reason #{e}"
+        return nil
+    end
+
+    def em_http(method,key,url,data,async_callback)
+        data[:retry]=0 if !data[:retry]
+        begin
+            raise "Retry too much time" if data[:retry]>RETRY_TIMES
+            
+            #conn options
+            conn_options = {
+              :connect_timeout => EM_REQUEST_TIMEOUT,        # default connection setup timeout
+              :inactivity_timeout => EM_INACTIVITY_TIMEOUT,    # default connection inactivity (post-setup) timeout
+            }
+            #data[:body]=data[:body] if data[:body].class==Hash && data[:head]['Content-Type'] && data[:head]['Content-Type']=="application/json"
+            #request options
+            data[:query]="?returnbody=true"
+            request_options=data.reject{|k,v| k==:retry}
+
+            #do job
+            case method
+            when "post"
+                riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).post request_options 
+            when "delete"
+                riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).delete request_options   
+            when "get"
+                riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).get request_options  
+            when "put"
+                riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).put request_options  
+            end
+
+            riakHttp.errback{ #Error Callback
+                puts "#{method} - #{key} - riak callback error #{riakHttp.response}" if EmRiak.debug
+                data[:retry]+=1
+                http(method,key,url,data,async_callback)
+            }
+
+            #Success Callback
+            riakHttp.callback{ 
+                puts "#{method} - #{url} - #{key} - riak response #{riakHttp.response}" if EmRiak.debug  
+                async_callback.call(riakHttp.response) if async_callback
+            }
+        rescue Exception => e
+            puts "em_http - #{method} - #{url} - #{key} error #{e}" if EmRiak.debug
+        end
+
+        # Return Response
+        res=if ["put","post"].index(method)
+            obj=EmRiak::StorageObject.new()
+            data.each{|k,v| obj[k]=v }
+            obj[:riak_key]=key if obj.length>0
+            obj
+        else
+            nil
+        end
+        res
+    end
+
+    def handle_callback(key,method,opts,callback,data={})
+        option_response=handle_options(method,opts)
+        if callback 
+            data[:head], data[:query] = option_response
+        else 
+            data[:head], data[:query], callback = option_response
+        end
+        
+        new_proc=Proc.new{|res|
+            obj=handle_response_string_to_object(key,res,method,data)
+            callback.call(obj)
+        } if callback
+        
+        [data,new_proc]
+    end
+    def handle_options(action,opts,header={},query="")
+        #Load default header setting
+        case action
+        when "save"
+            header["Content-Type"]="application/json"
+        when "get"
+            header["Content-Type"]="application/json"
+        when "destroy","delete"
+            header["Content-Type"]="application/json"
+        when "add_link"
+            header["Content-Type"]="application/json"
+        when "remove_link"
+        # else
+        #   header["Content-Type"]="application/json"
+        end
+        # Map & overwrite if header specisfic
+        opts=opts.first if opts && opts.class==Array
+
+        if opts && opts.count>0
+            # Map the options class
+            callback=opts.reject!{|obj| obj.class==Proc}
+
+            opts.each{|k,v|
+                meta=METAMAPPER[k]  
+                if meta
+                    header[meta[:key]] = meta[:value] 
+                    opts.reject!{true}
+                end
+            }
+
+            # --- Handle the rest headers
+            # Link Walk
+            if opts[:links] && (["save"].index(action))
+                links=[]
+                opts[:links].each{|link| links << %Q[</buckets/#{bucket}/keys/#{link[:target]}>; riaktag="#{link[:tag]}"] }
+                header['Link']= links.join(",")
+            elsif opts[:links] && (["add_link","remove_link"].index(action))
+                links=[]
+                opts[:links].each{|link| links << %Q[</buckets/#{bucket}/keys/#{link[:target]}>; riaktag="#{link[:tag]}"] }
+                header['Link']= links
+            elsif opts[:links] && action=="get"
+                header["Content-Type"]="multipart/mixed"
+                header["Accept"]="multipart/mixed"
+                header[:link]=""
+                keep=opts[:links][:keep] ? '1' : '0' #keep the result
+                opts[:links][:tag].each{|tag| header[:link]+= "/#{bucket},#{tag},#{keep}" }
+            end
+            # 2i
+            header["x-riak-index-#{opts[:bin].to_s}_bin"]=opts[:secondary_index].join(", ") if opts[:secondary_index]
+
+            # Replication, available configs : w, dw, pw
+            # read more at http://docs.basho.com/riak/latest/references/apis/http/HTTP-Store-Object/
+            replication.each{|key,value| hreader[key.to_s]=value} if replication
+
+            header["Content-Type"]=opts[:content_type] if opts[:content_type]
+            header["X-Riak-Vclock"]=opts[:vlock] if opts[:vlock]
+            header["ETag"]=opts[:etag] if opts[:etag]
+            header["Last-Modified"]=opts[:last_modified] if opts[:last_modified]
+            header["returnbody"]= "true" if !async
+            #header["unique"] = true if async=false
+            query="?returnbody=true"
+            opts[:query].each{|k,v| query+="&#{k}={v}" } if opts[:query]
+        end
+        res=[header,query]
+        res << callback if callback
+        res
+    end
+
+    def key_handler(key,map={"["=>"%5B","]"=>"%5D","+"=>"%2B","/"=>"%2F","("=>"%28",")"=>"%29",":"=>"%3A"})
+        # To match the key rule from Basho : If your field contains special characters, such as (‘+’,‘/’,‘[’,‘]’,‘(’,‘)’,‘:’ or space), then either surround the phrase in single quotes, or escape each special character with a backslash.
+        # map.each{|origin,value| key.gsub!(origin,value) }
+        EscapeUtils.escape_url(key.to_s.encode('UTF-8'))
+    end
+
+    def json_encode(obj,times=0)
+        y=Yajl::Encoder.new()
+        y.encode(obj)
+    rescue Exception => e
+        puts "json_encode error : #{e}" if EmRiak.debug
+        obj
+    end
+    def json_decode(obj,times=0)
+        y=Yajl::Parser.new()
+        y.parse(obj)
+    rescue Exception => e
+        puts "json_decode error : #{e}" if EmRiak.debug
+        obj
+    end
+
+    def convert_params_layers(origin,to_type,params={})
+      origin.each{|key,value|
+        converted=convert_params_layers(value,to_type) if value.class==Hash
+        key=key.send(to_type)
+        params[key]= converted ? converted : value
+      } if origin
+      params
+    end
+
+    private
+    def generate_path(url); EmRiak.hosts[rand(EmRiak.hosts.length)]+url; end
+    def has_http_instance?
+        if !EmRiak.http_client
+            HTTPI.log=false
+            HTTPI.adapter=:net_http
+            EmRiak.http_client=HTTPI::Request.new
+        end
+    end
 end