fastdfs-client 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28e3d4bb5c9868a72bac8476c6d0580e124d852a
-  data.tar.gz: 8889ef8b0df440d0ca99e3d1c213d9d2d6a7d9c1
+  metadata.gz: 83f837406bfbb7c59a4da740450c49232800e481
+  data.tar.gz: 900430e39aeea9db93faf42c460394eeb9087277
 SHA512:
-  metadata.gz: 26e0eb1ebbf0d1d4934966f451e68db1e9bd280ab42e8c5ff1c822041f9e9b8ba5715e55e10cb145adacdffe79255b039b8bf3a1d1a2b939ee19712bb915100c
-  data.tar.gz: 3a917eafa99d2dd236a99c28e3ab7dd851e3b20a64e2fd866253b1c39fa592f7ca87d273aaa91e7270bc3ebe0bbec19c129fb13fe9bd32a6067683d52a561f34
+  metadata.gz: 106f6c4cc8406215c7fe22d4935e4b72538f8e7f70874c1f66e129eac483669f8d2d1493bb09f15b2a2d2389fa8e34ffdc21ba5b3944361b53c35836838f303d
+  data.tar.gz: a12327a458920d7c1b4eccdf4828c1a7dc24d3ad0a7bd3d58d108b22fa7932d0cc050d1b0d3dc03b6a9bde3022dd33b349be9245383f18681f786ebc8ed06794

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fastdfs-client (0.0.2)
+    fastdfs-client (0.0.5)
 
 GEM
   remote: http://gems.ruby-china.org/

data/README.md

@@ -10,12 +10,28 @@ fastdfs client for ruby
 ### Using
 
 ```RUBY
+
+  # return the result format 
+  #  {status: true, err_msg: "", result: ...}
+  #
+
+
   tracker = new Fastdfs::Client::Tracker("192.168.1.1", "22122")
 
   @storage = tracker.get_storage
 
   @storage.upload(@file)
+  #result: {group_name: "group1", path: "m1/xfsd/fds.jpg"}
+
+  @storage.delete(path, group_name)  
+
+  # flag params [cover, merge]
+  @storage.set_metadata(path, group_name, {author: "kaka", width: "300"}, flag)
+
+  @storage.get_metadata(path, group_name) 
+  #result: {author: "kaka", width: "300"}
+
+  @storage.download(path, group_name) 
+  #result: #<Tempfile:/var/folders/m7/bt2j0rk54x555t44dpn4b7bm0000gn/T/test.jpg20160416-43738-1560vq3>  
 
-  #group_name + path
-  @storage.delete(path)
 ```

data/lib/fastdfs-client/cmd.rb

@@ -6,6 +6,9 @@ module Fastdfs
       UPLOAD_FILE = 11
       RESP_CODE = 100
       DELETE_FILE = 12
+      GET_METADATA = 15
+      SET_METADATA = 13
+      DOWNLOAD_FILE = 14
     end
 
   end

data/lib/fastdfs-client/proto_common.rb

@@ -11,8 +11,16 @@ module Fastdfs
       EXTNAME_LEN = 6
       GROUP_NAME_MAX_LEN = 16
 
+      RECV_MAX_LEN = 2 * 1024
+
+      RECORD_SEPERATOR = "\u0001"
+      FILE_SEPERATOR = "\u0002"
+
+      SET_METADATA_FLAG_OVERWRITE = "O"
+      SET_METADATA_FLAG_MERGE = "M"
+
       def self.header_bytes(cmd, hex_long, erron=0)
-        hex_bytes = Utils.number_to_Buffer(hex_long)
+        hex_bytes = Utils.number_to_buffer(hex_long)
         header = hex_bytes.fill(0, hex_bytes.length...HEAD_LEN)
         header[8] = cmd
         header[9] = erron

data/lib/fastdfs-client/socket.rb

@@ -10,13 +10,12 @@ module Fastdfs
       attr_accessor :header, :content, :header_len, :cmd, :socket, :host, :port
 
       def initialize(host, port, options = {})
-        @host = host
-        @port = port
-        connection
+        @host, @port = host, port
         @header_len = ProtoCommon::HEAD_LEN
         @options = options || {}
         @connection_timeout = @options[:connection_timeout] || 3
-        @recv_timeout = @options[:recv_timeout] || 3
+        @recv_timeout = @options[:recv_timeout] || 20
+        connection
       end
 
       def write(*args)
@@ -42,26 +41,54 @@ module Fastdfs
         !@socket.closed?
       end
 
-      def receive
-        @content = nil
-        Timeout.timeout(@recv_timeout) do 
+      def receive(&block)
+        timeout_recv do 
           @header = @socket.recv(@header_len).unpack("C*")
         end
         res_header = parseHeader
-        if res_header[:body_length] > 0
-          Timeout.timeout(@recv_timeout) do 
-            @content = @socket.recv(@header.to_pack_long) 
-          end
+        if res_header[:status]
+          recv_body if is_recv?
+          res = yield(@content) if block_given?
+          res_header[:result] = res unless res.nil?
         end
-        yield @content if block_given?
+        res_header
       end
 
       private
       def parseHeader
-        raise "recv package size #{@header} != #{@header_len}, cmd: #{@cmd}" unless @header.length == @header_len
-        raise "recv cmd: #{@header[8]} is not correct, expect cmd: #{CMD::RESP_CODE}, cmd: #{@cmd}" unless @header[8] == CMD::RESP_CODE
-        raise "recv erron #{@header[9]} 0 is correct, cmd: #{@cmd}" unless @header[9] == 0
-        {status: true, body_length: @header[0...8].to_pack_long}
+        err_msg = ""
+        err_msg = "recv package size #{@header} is not equal #{@header_len}, cmd: #{@cmd}" unless @header.length == @header_len
+        err_msg = "recv cmd: #{@header[8]} is not correct, expect cmd: #{CMD::RESP_CODE}, cmd: #{@cmd}" unless @header[8] == CMD::RESP_CODE
+        err_msg = "recv erron #{@header[9]}, 0 is correct cmd: #{@cmd}" unless @header[9] == 0
+        {status: err_msg.blank?, err_msg: err_msg}
+      end
+
+      def timeout_recv
+        Timeout.timeout(@recv_timeout) do 
+          yield if block_given?
+        end
+      end
+
+      def is_recv?
+        recv_body_len > 0
+      end
+
+      def recv_body_len
+        @header[0...8].to_pack_long
+      end
+
+      def recv_body
+        @content = ""
+        max_len, body_len = ProtoCommon::RECV_MAX_LEN, recv_body_len
+
+        while body_len > 0
+          timeout_recv do 
+            len = [body_len, max_len].min
+            @content << @socket.recv(len) 
+            body_len -= len
+          end
+        end
+        @content = nil if @content.blank?
       end
 
     end

data/lib/fastdfs-client/storage.rb

@@ -6,8 +6,8 @@ module Fastdfs
     class Storage
       extend Hook
 
-      before(:upload, :delete){ @socket.connection }
-      after(:upload, :delete){ @socket.close }
+      before(:upload, :delete, :get_metadata, ){ @socket.connection }
+      after(:upload, :delete, :get_metadata, ){ @socket.close }
 
       attr_accessor :host, :port, :group_name, :store_path, :socket, :options
 
@@ -28,26 +28,89 @@ module Fastdfs
 
       def delete(path, group_name = nil)
         cmd = CMD::DELETE_FILE
+        path_bytes = header_path_bytes(cmd, path, group_name)
+        @socket.write(cmd, path_bytes)
+        @socket.receive{ true }
+      end
+
+      def get_metadata(path, group_name = nil)
+        cmd = CMD::GET_METADATA
+        path_bytes = header_path_bytes(cmd, path, group_name)
+        @socket.write(cmd, path_bytes)
+        @socket.receive do |content|
+          res = content.split(ProtoCommon::RECORD_SEPERATOR).map do |c| 
+            c.split(ProtoCommon::FILE_SEPERATOR) 
+          end.flatten
+          Utils.symbolize_keys(Hash[*res])
+        end
+      end
+
+      def set_metadata(path, group_name = nil, options = {}, flag = :cover)
+        cmd = CMD::SET_METADATA
+        
+        unless options.is_a?(Hash)
+          flag = options
+          options = {}
+        end
+
+        if group_name.is_a?(Hash)
+          options = group_name
+          group_name = nil
+        end
+        flag = convert_meta_flag(flag)
+        group_bytes, path_bytes = group_path_bytes(path, group_name)
+        meta_bytes = meta_to_bytes(options)
+
+        size_bytes = Utils.number_to_buffer(path_bytes.length) + Utils.number_to_buffer(meta_bytes.length)
+        size_bytes = (size_bytes).fill(0, size_bytes.length...16)
+        total = size_bytes.length + flag.length + group_bytes.length + path_bytes.length + meta_bytes.length
+        header_bytes = ProtoCommon.header_bytes(cmd, total)
+        @socket.write(cmd, (header_bytes + size_bytes + flag.bytes + group_bytes + path_bytes))
+        @socket.write(cmd, meta_bytes) 
+        @socket.receive
+      end
+
+      def download(path, group_name = nil)
+        cmd = CMD::DOWNLOAD_FILE
+        group_bytes, path_bytes = group_path_bytes(path, group_name)
+        download_bytes = Utils.number_to_buffer(0) + Utils.number_to_buffer(0)
+
+        header_bytes = ProtoCommon.header_bytes(cmd, group_bytes.length + path_bytes.length + download_bytes.length)
+
+        @socket.write(cmd, header_bytes + download_bytes + group_bytes + path_bytes)
+        @socket.receive do |body|
+          create_tempfile(path, body) if body
+        end
+      end
+
+      private
+      def group_path_bytes(path, group_name = nil)
+        group_name, path = extract_path!(path, group_name)
+        group_bytes = group_name.bytes.fill(0, group_name.length...ProtoCommon::GROUP_NAME_MAX_LEN)
+        [group_bytes, path.bytes]
+      end      
+
+      def header_path_bytes(cmd, path, group_name = nil)
+        path_bytes = group_path_bytes(path, group_name).flatten
+        return (ProtoCommon.header_bytes(cmd, path_bytes.length) + path_bytes)
+      end
+
+      def extract_path!(path, group_name = nil)
         raise "path arguments is empty!" if path.blank?
         if group_name.blank?
           group_name = /^\/?(\w+)/.match(path)[1]
           path = path.gsub(Regexp.new("/?#{group_name}/?"), "")
         end
         raise "group_name arguments is empty!" if group_name.blank?
-        group_bytes = group_name.bytes.fill(0, group_name.length...ProtoCommon::GROUP_NAME_MAX_LEN)
-        path_length = (group_bytes.length + path.bytes.length)
-
-        @socket.write(cmd, (ProtoCommon.header_bytes(cmd, path_length) + group_bytes + path.bytes))
-        @socket.receive{ true }
+        return group_name, path
       end
 
-      private 
       def _upload(file)
         cmd = CMD::UPLOAD_FILE
 
         extname = File.extname(file)[1..-1]
         ext_name_bs = extname.bytes.fill(0, extname.length...@extname_len)
-        hex_len_bytes = Utils.number_to_Buffer(file.size)
+        hex_len_bytes = Utils.number_to_buffer(file.size)
         size_byte = [@store_path].concat(hex_len_bytes).fill(0, (hex_len_bytes.length+1)...@size_len)
 
         header = ProtoCommon.header_bytes(cmd, (size_byte.length + @extname_len + file.size))
@@ -58,12 +121,34 @@ module Fastdfs
         @socket.receive do |body|
           group_name_max_len = ProtoCommon::GROUP_NAME_MAX_LEN
           
-          {
-            group_name: body[0...group_name_max_len].strip, 
-            path: body[group_name_max_len..-1]
-          }
+          {group_name: body[0...group_name_max_len].strip, path: body[group_name_max_len..-1]}
         end
       end
+
+      def convert_meta_flag(flag)
+        data = {
+          cover: ProtoCommon::SET_METADATA_FLAG_OVERWRITE,
+          merge: ProtoCommon::SET_METADATA_FLAG_MERGE
+        }
+        flag = :cover if flag.blank?
+        data[flag.to_sym]
+      end
+
+      def meta_to_bytes(options = {})
+        meta_bytes = options.map do |a| 
+          a.join(ProtoCommon::FILE_SEPERATOR) 
+        end.join(ProtoCommon::RECORD_SEPERATOR).bytes
+        meta_bytes << 0 if meta_bytes.blank?
+        meta_bytes
+      end
+
+      def create_tempfile(path, body)
+        tmp = Tempfile.new(path.gsub(/\//, "_"))
+        tmp.binmode
+        tmp.write(body)
+        tmp.close
+        tmp
+      end
       
     end
 

data/lib/fastdfs-client/tracker.rb

@@ -19,15 +19,14 @@ module Fastdfs
       def get_storage
         header = ProtoCommon.header_bytes(@cmd, 0)
         @socket.write(@cmd, header)
-        @socket.receive do |body|
-          storage_ip = body[ProtoCommon::IPADDR].strip
-          storage_port = body[ProtoCommon::PORT].unpack("C*").to_pack_long
-          store_path = body[ProtoCommon::TRACKER_BODY_LEN-1].unpack("C*")[0]
-          
-          Storage.new(storage_ip, storage_port, store_path, options)
-        end
-
-
+        res = @socket.receive
+        return res unless res[:status]
+
+        storage_ip = @socket.content[ProtoCommon::IPADDR].strip
+        storage_port = @socket.content[ProtoCommon::PORT].unpack("C*").to_pack_long
+        store_path = @socket.content[ProtoCommon::TRACKER_BODY_LEN-1].unpack("C*")[0]
+        
+        Storage.new(storage_ip, storage_port, store_path, options)
       end
     end
 

data/lib/fastdfs-client/utils.rb

@@ -1,6 +1,6 @@
 module Utils
 
-  def self.number_to_Buffer(num)
+  def self.number_to_buffer(num)
     8.times.map{|i| (num >> (56 - 8 * i)) & 255}
   end
 
@@ -10,4 +10,7 @@ module Utils
     arr1
   end
 
+  def self.symbolize_keys(obj)
+    obj.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+  end
 end

data/lib/fastdfs-client/version.rb

@@ -1,5 +1,5 @@
 module Fastdfs
   module Client
-    VERSION = '0.0.3'
+    VERSION = '0.0.5'
   end
 end

data/spec/mock_tcp_socket.rb

@@ -45,7 +45,7 @@ class TCPSocket
 
           group_name = Utils.array_merge([].fill(0, 0...16), TestConfig::GROUP_NAME.bytes)
           ip = Utils.array_merge([].fill(0, 0...15), TestConfig::STORAGE_IP.bytes)
-          port = Utils.number_to_Buffer(TestConfig::STORAGE_PORT.to_i)
+          port = Utils.number_to_buffer(TestConfig::STORAGE_PORT.to_i)
           store_path = Array(TestConfig::STORE_PATH)
 
           (header+group_name+ip+port+store_path)[@recv_offset...@recv_offset+len].pack("C*")
@@ -68,6 +68,28 @@ class TCPSocket
           header = ProtoCommon.header_bytes(CMD::RESP_CODE, 0)
           header.pack("C*")
         end
+      },
+      "15" => {
+        recv_bytes: lambda do |len|
+          header = ProtoCommon.header_bytes(CMD::RESP_CODE, 0)
+          body = TestConfig::METADATA.map{|a| a.join(ProtoCommon::FILE_SEPERATOR)}.join(ProtoCommon::RECORD_SEPERATOR).bytes
+          header[7] = body.length
+          (header + body)[@recv_offset...@recv_offset+len].pack("C*")
+        end
+      },
+      "13" => {
+        recv_bytes: lambda do |len|
+          header = ProtoCommon.header_bytes(CMD::RESP_CODE, 0)
+          header.pack("C*")
+        end
+      },
+      "14" => {
+        recv_bytes: lambda do |len|
+          header = ProtoCommon.header_bytes(CMD::RESP_CODE, 0)
+          body = IO.read(TestConfig::FILE).bytes
+          header[7] = body.length
+          (header + body)[@recv_offset...@recv_offset+len].pack("C*")
+        end
       }
     }
   end

data/spec/storage_spec.rb

@@ -8,33 +8,50 @@ describe Fastdfs::Client::Storage do
   let(:tracker){ FC::Tracker.new(host, port) }
   let(:storage){ tracker.get_storage }
 
-  it "initialize the server" do 
-    expect(FC::Socket).to receive(:new).with(host, port, nil) 
-    FC::Storage.new(host, port) 
-  end
-
-  it "should have access to the storage connection" do
-    expect(storage.socket).to receive(:connection)
-    expect(storage.socket).to receive(:close)
-    storage.upload(TestConfig::FILE)
-  end
-
-  it "should the result attributes group_name and path" do 
-    res = storage.upload(TestConfig::FILE)
-    expect(res).to include(:group_name)
-    expect(res).to include(:path)
-  end
-
-  it "can delete file by group and path" do 
-    res = storage.upload(TestConfig::FILE)
-    storage.delete(res[:path], res[:group_name])
-  end
+  # it "initialize the server" do 
+  #   expect(FC::Socket).to receive(:new).with(host, port, nil) 
+  #   FC::Storage.new(host, port) 
+  # end
+
+  # it "should have access to the storage connection" do
+  #   expect(storage.socket).to receive(:connection)
+  #   expect(storage.socket).to receive(:close)
+  #   storage.upload(TestConfig::FILE)
+  # end
+
+  # it "should the result attributes group_name and path" do 
+  #   res = storage.upload(TestConfig::FILE)
+  #   expect(res[:status]).to be_truthy
+  #   expect(res[:result]).to include(:group_name)
+  #   expect(res[:result]).to include(:path)
+  # end
+
+  # it "can delete file by group and path" do 
+  #   res = storage.upload(TestConfig::FILE)[:result]
+  #   storage.delete(res[:path], res[:group_name])
+  # end
+
+  # it "can delete file raise exception" do 
+  #   res = storage.upload(TestConfig::FILE)[:result]
+  #   result = FC::ProtoCommon.header_bytes(FC::CMD::RESP_CODE, 0, 22)
+  #   TCPSocket.any_instance.stub("recv").and_return(result.pack("C*"))
+  #   expect( storage.delete("fdsaf", res[:group_name])[:status] ).to be_falsey
+  # end
+
+  # it "can get metadata results" do 
+  #   res = storage.get_metadata("#{TestConfig::GROUP_NAME}/#{TestConfig::FILE_NAME}")
+  #   expect(res[:result]).to eq(TestConfig::METADATA)
+  # end
+
+  # it "can set metadata" do 
+  #   expect(storage.set_metadata(TestConfig::FILE_NAME, TestConfig::GROUP_NAME, TestConfig::METADATA)).to be_truthy
+  # end
+
+  it "download the file to the local" do 
+    res = storage.download("M00/04/46/wKgIF1b7XLWAI2Q6AAACVHeY6n8655.png", "group1")
+    expect(res[:status]).to be_truthy
+    expect(res[:result]).to be_an_instance_of(Tempfile)
+    expect(IO.read(res[:result])).to eq(IO.read(TestConfig::FILE))
 
-  it "can delete file raise exception" do 
-    res = storage.upload(TestConfig::FILE)
-    result = FC::ProtoCommon.header_bytes(FC::CMD::RESP_CODE, 0, 22)
-    TCPSocket.any_instance.stub("recv").and_return(result.pack("C*"))
-    expect{ storage.delete("fdsaf", res[:group_name]) }.to raise_error(RuntimeError)
   end
-
 end

data/spec/test_config.rb

@@ -5,6 +5,13 @@ module TestConfig
   GROUP_NAME = "group1"
   FILE_NAME = "M00/04/47/wKgIF1cHcQyAeAF7AAACVHeY6n8267.png"
 
+  METADATA = {
+    width: "800",
+    height: "600",
+    bgcolor: 'red',
+    author: "kaka"
+  }
+
   FILE = Tempfile.new("test.jpg")
   FILE.write("testtest")
   FILE.close

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastdfs-client
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Ka Ka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-12 00:00:00.000000000 Z
+date: 2016-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
 - Gemfile
 - Gemfile.lock
 - README.md