2.92

mount: add back support for filer.path
Merge pull request #2716 from dave-b-code/patch-1
2026-10-01 20:26:27 +00:00 · 2022-02-28 15:22:19 -08:00 · 2022-02-28 12:16:53 -08:00 · 2022-02-28 10:10:59 -08:00 · 2022-02-28 10:07:06 -08:00 · 2022-02-28 02:08:24 -08:00
219 changed files with 6748 additions and 5517 deletions
@@ -20,12 +20,12 @@ jobs:
          assets: |
            weed-*

-  build_dev_linux:
+  build_dev_linux_windows:
    needs: cleanup
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        goos: [linux]
+        goos: [linux, windows]
        goarch: [amd64]

    steps:
@@ -68,7 +68,7 @@ jobs:
          asset_name: "weed-${{ env.BUILD_TIME }}-${{ matrix.goos }}-${{ matrix.goarch }}"

  build_dev_darwin:
-    needs: build_dev_linux
+    needs: build_dev_linux_windows
    runs-on: ubuntu-latest
    strategy:
      matrix:
@@ -41,6 +41,7 @@ Your support will be really appreciated by me and other supporters!
 - [Download Binaries for different platforms](https://github.com/chrislusf/seaweedfs/releases/latest)
 - [SeaweedFS on Slack](https://join.slack.com/t/seaweedfs/shared_invite/enQtMzI4MTMwMjU2MzA3LTEyYzZmZWYzOGQ3MDJlZWMzYmI0OTE4OTJiZjJjODBmMzUxNmYwODg0YjY3MTNlMjBmZDQ1NzQ5NDJhZWI2ZmY)
 - [SeaweedFS on Twitter](https://twitter.com/SeaweedFS)
+- [SeaweedFS on Telegram](https://t.me/Seaweedfs) 
 - [SeaweedFS Mailing List](https://groups.google.com/d/forum/seaweedfs)
 - [Wiki Documentation](https://github.com/chrislusf/seaweedfs/wiki)
 - [SeaweedFS White Paper](https://github.com/chrislusf/seaweedfs/wiki/SeaweedFS_Architecture.pdf)
@@ -51,6 +52,8 @@ Table of Contents
 =================

 * [Quick Start](#quick-start)
+    * [Quick Start for S3 API on Docker](#quick-start-for-s3-api-on-docker)
+    * [Quick Start with Single Binary](#quick-start-with-single-binary)
 * [Introduction](#introduction)
 * [Features](#features)
    * [Additional Features](#additional-features)
@@ -73,7 +76,7 @@ Table of Contents

 `docker run -p 8333:8333 chrislusf/seaweedfs server -s3`

-## Quick Start with single binary ##
+## Quick Start with Single Binary ##
 * Download the latest binary from https://github.com/chrislusf/seaweedfs/releases and unzip a single binary file `weed` or `weed.exe`
 * Run `weed server -dir=/some/data/dir -s3` to start one master, one volume server, one filer, and one S3 gateway.

@@ -9,7 +9,7 @@ ENV ROCKSDB_VERSION v6.22.1
 RUN cd /tmp && \
    git clone https://github.com/facebook/rocksdb.git /tmp/rocksdb --depth 1 --single-branch --branch $ROCKSDB_VERSION && \
    cd rocksdb && \
-    make static_lib && \
+    PORTABLE=1 make static_lib && \
    make install-static

 ENV CGO_CFLAGS "-I/tmp/rocksdb/include"
@@ -29,7 +29,7 @@ FROM alpine AS final
 LABEL author="Chris Lu"
 COPY --from=builder /go/bin/weed /usr/bin/
 RUN mkdir -p /etc/seaweedfs
-COPY --from=builder /go/src/github.com/chrislusf/seaweedfs/docker/filer.toml /etc/seaweedfs/filer.toml
+COPY --from=builder /go/src/github.com/chrislusf/seaweedfs/docker/filer_rocksdb.toml /etc/seaweedfs/filer.toml
 COPY --from=builder /go/src/github.com/chrislusf/seaweedfs/docker/entrypoint.sh /entrypoint.sh
 RUN apk add fuse snappy gflags

@@ -50,7 +50,7 @@ EXPOSE 8333
 # webdav server http port
 EXPOSE 7333

-RUN mkdir -p /data/filerldb2
+RUN mkdir -p /data/filer_rocksdb

 VOLUME /data

@@ -24,7 +24,7 @@ case "$1" in
  'master')
  	ARGS="-mdir=/data -volumePreallocate -volumeSizeLimitMB=1024"
  	shift
-  	exec /usr/bin/weed master $ARGS $@
+  	exec /usr/bin/weed -logtostderr=true master $ARGS $@
 	;;

  'volume')
@@ -33,7 +33,7 @@ case "$1" in
  	  ARGS="-dir=/data"
  	fi
  	shift
-  	exec /usr/bin/weed volume $ARGS $@
+  	exec /usr/bin/weed -logtostderr=true volume $ARGS $@
 	;;

  'server')
@@ -42,19 +42,19 @@ case "$1" in
  	  ARGS="-dir=/data -master.volumePreallocate -master.volumeSizeLimitMB=1024"
  	fi
 	shift
-  	exec /usr/bin/weed server $ARGS $@
+  	exec /usr/bin/weed -logtostderr=true server $ARGS $@
  	;;

  'filer')
  	ARGS=""
  	shift
-  	exec /usr/bin/weed filer $ARGS $@
+  	exec /usr/bin/weed -logtostderr=true filer $ARGS $@
 	;;

  's3')
  	ARGS="-domainName=$S3_DOMAIN_NAME -key.file=$S3_KEY_FILE -cert.file=$S3_CERT_FILE"
  	shift
-  	exec /usr/bin/weed s3 $ARGS $@
+  	exec /usr/bin/weed -logtostderr=true s3 $ARGS $@
 	;;

  *)
@@ -0,0 +1,3 @@
+[rocksdb]
+enabled = true
+dir = "/data/filer_rocksdb"
@@ -8,7 +8,6 @@ require (
 	cloud.google.com/go/storage v1.16.1
 	github.com/Azure/azure-pipeline-go v0.2.3
 	github.com/Azure/azure-storage-blob-go v0.14.0
-	github.com/DataDog/zstd v1.3.6-0.20190409195224-796139022798 // indirect
 	github.com/OneOfOne/xxhash v1.2.2
 	github.com/Shopify/sarama v1.23.1
 	github.com/aws/aws-sdk-go v1.35.3
@@ -44,7 +43,7 @@ require (
 	github.com/go-zookeeper/zk v1.0.2 // indirect
 	github.com/gocql/gocql v0.0.0-20210707082121-9a3953d1826d
 	github.com/golang-jwt/jwt v3.2.1+incompatible
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/protobuf v1.5.2
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/btree v1.0.0
@@ -100,7 +99,6 @@ require (
 	github.com/prometheus/procfs v0.6.0 // indirect
 	github.com/rcrowley/go-metrics v0.0.0-20190826022208-cac0b30c2563 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
-	github.com/seaweedfs/fuse v1.2.2
 	github.com/seaweedfs/goexif v1.0.2
 	github.com/sirupsen/logrus v1.6.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
@@ -163,20 +161,22 @@ require (
 	modernc.org/token v1.0.0 // indirect
 )

+require (
+	github.com/fluent/fluent-logger-golang v1.8.0
+	github.com/hanwen/go-fuse/v2 v2.1.0
+)
+
 require (
 	cloud.google.com/go/kms v1.0.0 // indirect
-	github.com/apache/thrift v0.15.0 // indirect
+	github.com/DataDog/zstd v1.3.6-0.20190409195224-796139022798 // indirect
 	github.com/d4l3k/messagediff v1.2.1 // indirect
-	github.com/fluent/fluent-logger-golang v1.8.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/gorilla/websocket v1.4.2 // indirect
 	github.com/jcmturner/aescts/v2 v2.0.0 // indirect
 	github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect
 	github.com/jcmturner/goidentity/v6 v6.0.1 // indirect
 	github.com/jcmturner/rpc/v2 v2.0.2 // indirect
 	github.com/mattn/go-runewidth v0.0.7 // indirect
 	github.com/mattn/go-sqlite3 v2.0.1+incompatible // indirect
-	github.com/miekg/dns v1.1.44 // indirect
 	github.com/philhofer/fwd v1.1.1 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/tinylib/msgp v1.1.6 // indirect
@@ -191,5 +191,4 @@ require (
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 )

-// replace github.com/seaweedfs/fuse => /Users/chrislu/go/src/github.com/seaweedfs/fuse
 // replace github.com/chrislusf/raft => /Users/chrislu/go/src/github.com/chrislusf/raft
@@ -124,8 +124,6 @@ github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk5
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
-github.com/apache/thrift v0.15.0 h1:aGvdaR0v1t9XLgjtBYwxcBvBOTMqClzwE26CHOgjW1Y=
-github.com/apache/thrift v0.15.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU=
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
@@ -281,30 +279,6 @@ github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-zookeeper/zk v1.0.2 h1:4mx0EYENAdX/B/rbunjlt5+4RTA/a9SMHBRuSKdGxPM=
 github.com/go-zookeeper/zk v1.0.2/go.mod h1:nOB03cncLtlp4t+UAkGSV+9beXP/akpekBwL+UX1Qcw=
-github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0=
-github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY=
-github.com/gobuffalo/depgen v0.1.0/go.mod h1:+ifsuy7fhi15RWncXQQKjWS9JPkdah5sZvtHc2RXGlg=
-github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
-github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
-github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs=
-github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
-github.com/gobuffalo/flect v0.1.3/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
-github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk=
-github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28=
-github.com/gobuffalo/genny v0.1.0/go.mod h1:XidbUqzak3lHdS//TPu2OgiFB+51Ur5f7CSnXZ/JDvo=
-github.com/gobuffalo/genny v0.1.1/go.mod h1:5TExbEyY48pfunL4QSXxlDOmdsD44RRq4mVZ0Ex28Xk=
-github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw=
-github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360=
-github.com/gobuffalo/gogen v0.1.0/go.mod h1:8NTelM5qd8RZ15VjQTFkAW6qOMx5wBbW4dSCS3BY8gg=
-github.com/gobuffalo/gogen v0.1.1/go.mod h1:y8iBtmHmGc4qa3urIyo1shvOD8JftTtfcKi+71xfDNE=
-github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8=
-github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
-github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
-github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
-github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
-github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ=
-github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0=
-github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw=
 github.com/gocql/gocql v0.0.0-20210707082121-9a3953d1826d h1:k544nNVphXK4Yt0FTduvOvCfJabEY/DMkdNw0zpCwBE=
 github.com/gocql/gocql v0.0.0-20210707082121-9a3953d1826d/go.mod h1:3gM2c4D3AnkISwBxGnMMsS8Oy4y2lhbPRsH4xnJrHG8=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
@@ -431,8 +405,6 @@ github.com/gorilla/sessions v1.2.0 h1:S7P+1Hm5V/AT9cjEcUD5uDaQSX0OE577aCXgoaKpYb
 github.com/gorilla/sessions v1.2.0/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM=
 github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
-github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
-github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-middleware v1.1.0 h1:THDBEeQ9xZ8JEaCLyLQqXMMdRqNr0QAUJTIkQAUtFjg=
@@ -443,6 +415,10 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
+github.com/hanwen/go-fuse v1.0.0 h1:GxS9Zrn6c35/BnfiVsZVWmsG803xwE7eVRDvcf/BEVc=
+github.com/hanwen/go-fuse v1.0.0/go.mod h1:unqXarDXqzAk0rt98O2tVndEPIpUgLD9+rwFisZH3Ok=
+github.com/hanwen/go-fuse/v2 v2.1.0 h1:+32ffteETaLYClUj0a3aHjZ1hOPxxaNEHiZiujuDaek=
+github.com/hanwen/go-fuse/v2 v2.1.0/go.mod h1:oRyA5eK+pvJyv5otpO/DgccS8y/RvYMaO00GgRLGryc=
 github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
 github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
 github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
@@ -516,16 +492,11 @@ github.com/karlseguin/ccache/v2 v2.0.7 h1:y5Pfi4eiyYCOD6LS/Kj+o6Nb4M5Ngpw9qFQs+v
 github.com/karlseguin/ccache/v2 v2.0.7/go.mod h1:2BDThcfQMf/c0jnZowt16eW405XIqZPavt+HoYEtcxQ=
 github.com/karlseguin/expect v1.0.2-0.20190806010014-778a5f0c6003 h1:vJ0Snvo+SLMY72r5J4sEfkuE7AFbixEP2qRbEcum/wA=
 github.com/karlseguin/expect v1.0.2-0.20190806010014-778a5f0c6003/go.mod h1:zNBxMY8P21owkeogJELCLeHIt+voOSduHYTFUbwRAV8=
-github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4=
-github.com/karrick/godirwalk v1.10.3/go.mod h1:RoGL9dQei4vP9ilrpETWE8CLOZ1kiN0LhBygSwrAsHA=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.9.5/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
-github.com/klauspost/compress v1.10.9 h1:pPRt1Z78crspaHISkpSSHjDlx+Tt9suHe519dsI0vF4=
-github.com/klauspost/compress v1.10.9/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
 github.com/klauspost/cpuid v1.2.1 h1:vJi+O/nMdFt0vqm8NZBI6wzALWdA2X+egi0ogNyrC/w=
@@ -533,7 +504,6 @@ github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgo
 github.com/klauspost/reedsolomon v1.9.2 h1:E9CMS2Pqbv+C7tsrYad4YC9MfhnMVWhMRsTi7U0UB18=
 github.com/klauspost/reedsolomon v1.9.2/go.mod h1:CwCi+NUr9pqSVktrkN+Ondf06rkhYZ/pcNv7fu+8Un4=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
@@ -546,6 +516,8 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kurin/blazer v0.5.3 h1:SAgYv0TKU0kN/ETfO5ExjNAPyMt2FocO2s/UlCHfjAk=
 github.com/kurin/blazer v0.5.3/go.mod h1:4FCXMUWo9DllR2Do4TtBd377ezyAJ51vB5uTBjt0pGU=
+github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
+github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k=
 github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.10.0 h1:Zx5DJFEYQXio93kgXnQ09fXNiUKsqv4OUEu2UtGcB1E=
 github.com/lib/pq v1.10.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
@@ -559,8 +531,6 @@ github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzR
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mailru/easyjson v0.7.1 h1:mdxE1MF9o53iCb2Ghj1VfWvh7ZOwHpnVG/xwXrV90U8=
 github.com/mailru/easyjson v0.7.1/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE=
-github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-ieproxy v0.0.0-20190610004146-91bb50d98149/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc=
 github.com/mattn/go-ieproxy v0.0.0-20190702010315-6dee0af9227d/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc=
@@ -580,8 +550,6 @@ github.com/mattn/go-sqlite3 v2.0.1+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
-github.com/miekg/dns v1.1.44 h1:4rpqcegYPVkvIeVhITrKP1sRR3KjfRc1nrOPMUZmLyc=
-github.com/miekg/dns v1.1.44/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
@@ -721,27 +689,17 @@ github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6O
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
-github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
 github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
-github.com/seaweedfs/fuse v1.2.0 h1:m4Ar3I0TY/Tzyb80lfJiXUKFcMBHqA5e/cZwxQtilZo=
-github.com/seaweedfs/fuse v1.2.0/go.mod h1:iwbDQv5BZACY54r6AO/6xsLNuMaYcBKSkLTZVfmK594=
-github.com/seaweedfs/fuse v1.2.1 h1:920YH3+PnIqpNLo2lsZDTUJHUPLXnxgQGEXoVb/yMno=
-github.com/seaweedfs/fuse v1.2.1/go.mod h1:iwbDQv5BZACY54r6AO/6xsLNuMaYcBKSkLTZVfmK594=
-github.com/seaweedfs/fuse v1.2.2 h1:01l8OjIdyATRNqVc/gDPgFobuC8ubQF3hRKOPColROw=
-github.com/seaweedfs/fuse v1.2.2/go.mod h1:iwbDQv5BZACY54r6AO/6xsLNuMaYcBKSkLTZVfmK594=
 github.com/seaweedfs/goexif v1.0.2 h1:p+rTXYdQ2mgxd+1JaTrQ9N8DvYuw9UH9xgYmJ+Bb29E=
 github.com/seaweedfs/goexif v1.0.2/go.mod h1:MrKs5LK0HXdffrdCZrW3OIMegL2xXpC6ThLyXMyjdrk=
 github.com/secsy/goftp v0.0.0-20190720192957-f31499d7c79a h1:C6IhVTxNkhlb0tlCB6JfHOUv1f0xHPK7V8X4HlJZEJw=
 github.com/secsy/goftp v0.0.0-20190720192957-f31499d7c79a/go.mod h1:MnkX001NG75g3p8bhFycnyIjeQoOjGL6CEIsdE/nKSY=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.5.0/go.mod h1:+F7Ogzej0PZc/94MaYx/nvG9jOFMD2osvC3s+Squfpo=
 github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
@@ -792,17 +750,11 @@ github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08Yu
 github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203/go.mod h1:oqN97ltKNihBbwlX8dLpwxCl3+HnXKV/R0e+sRLd9C8=
 github.com/syndtr/goleveldb v1.0.1-0.20190318030020-c3a204f8e965 h1:1oFLiOyVl+W7bnBzGhf7BbIv9loSFQcieWWYIjLqcAw=
 github.com/syndtr/goleveldb v1.0.1-0.20190318030020-c3a204f8e965/go.mod h1:9OrXJhf154huy1nPWmuSrkgjPUtUNhA+Zmy+6AESzuA=
-github.com/tidwall/gjson v1.8.1 h1:8j5EE9Hrh3l9Od1OIEDAb7IpezNA20UdRngNAj5N0WU=
-github.com/tidwall/gjson v1.8.1/go.mod h1:5/xDoumyyDNerp2U36lyolv46b3uF/9Bu6OfyQ9GImk=
 github.com/tidwall/gjson v1.10.2 h1:APbLGOM0rrEkd8WBw9C24nllro4ajFuJu0Sc9hRz8Bo=
 github.com/tidwall/gjson v1.10.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
-github.com/tidwall/match v1.0.3 h1:FQUVvBImDutD8wJLN6c5eMzWtjgONK9MwIBCOrUJKeE=
-github.com/tidwall/match v1.0.3/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
 github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
 github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
-github.com/tidwall/pretty v1.1.0 h1:K3hMW5epkdAVwibsQEfR/7Zj0Qgt4DxtNumTq/VloO8=
-github.com/tidwall/pretty v1.1.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tidwall/pretty v1.2.0 h1:RWIZEg2iJ8/g6fDDYzMpobmaoGh5OLl4AXtGUGPcqCs=
 github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/tinylib/msgp v1.1.6 h1:i+SbKraHhnrf9M5MYmvQhFnbLhAXSDWF8WWsuyRdocw=
@@ -853,8 +805,6 @@ go.etcd.io/etcd/client/pkg/v3 v3.5.0 h1:2aQv6F436YnN7I4VbI8PPYrBhu+SmrTaADcf8Mi/
 go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g=
 go.etcd.io/etcd/client/v3 v3.5.0 h1:62Eh0XOro+rDwkrypAGDfgmNh5Joq+z+W9HZdlXMzek=
 go.etcd.io/etcd/client/v3 v3.5.0/go.mod h1:AIKXXVX/DQXtfTEqBryiLTUXwON+GuvO6Z7lLS/oTh0=
-go.mongodb.org/mongo-driver v1.7.0 h1:hHrvOBWlWB2c7+8Gh/Xi5jj82AgidK/t7KVXBZ+IyUA=
-go.mongodb.org/mongo-driver v1.7.0/go.mod h1:Q4oFMbo1+MSNqICAdYMlC/zSTrwCogR4R8NzkI+yfU8=
 go.mongodb.org/mongo-driver v1.8.0 h1:R/P/JJzu8LJvJ1lDfph9GLNIKQxEtIHFfnUUUve35zY=
 go.mongodb.org/mongo-driver v1.8.0/go.mod h1:0sQWfOeY63QTntERDJJ/0SuKK0T1uVSgKCuAROlKEPY=
 go.opencensus.io v0.15.0/go.mod h1:UffZAU+4sDEINUGP/B7UfBBkq4fqLu9zXAX7ke6CHW0=
@@ -898,7 +848,6 @@ golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190404164418-38d8ce5564a5/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
-golang.org/x/crypto v0.0.0-20190422162423-af44ce270edf/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@@ -907,7 +856,6 @@ golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
@@ -1003,7 +951,6 @@ golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d h1:LO7XpTYMwTqxjLcGWPijK3vRXg1aWdlNOVOHRq45d7c=
 golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -1027,7 +974,6 @@ golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -1048,11 +994,9 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190419153524-e8e3143a4f4a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190531175056-4c3a928424d2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1110,12 +1054,8 @@ golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210817142637-7d9622a276b7/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365 h1:6wSTsvPddg9gc/mVEEyk9oOAoxn+bT4Z9q1zx+4RwA4=
 golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
-golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220111092808-5a964db01320 h1:0jf+tOCoZ3LyutmCOWpVni1chK4VfFLhRsDK7MhqGRY=
 golang.org/x/sys v0.0.0-20220111092808-5a964db01320/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
@@ -1127,7 +1067,6 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
@@ -1144,9 +1083,6 @@ golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3
 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190416151739-9c9e1878f421/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190420181800-aa740d480789/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190422233926-fe54fb35175b/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
@@ -1205,7 +1141,6 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2 h1:BonxutuHCTL0rBDnZlKjpGIQFTjyUVTexFOdWkB6Fg0=
 golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
@@ -1,5 +1,5 @@
 apiVersion: v1
 description: SeaweedFS
 name: seaweedfs
-appVersion: "2.86"
-version: "2.86"
+appVersion: "2.92"
+version: "2.92"
@@ -130,7 +130,7 @@ spec:
              name: swfs-s3
          readinessProbe:
            httpGet:
-              path: /
+              path: /status
              port: {{ .Values.s3.port }}
              scheme: HTTP
            initialDelaySeconds: 15
@@ -140,7 +140,7 @@ spec:
            timeoutSeconds: 10
          livenessProbe:
            httpGet:
-              path: /
+              path: /status
              port: {{ .Values.s3.port }}
              scheme: HTTP
            initialDelaySeconds: 20
@@ -40,7 +40,7 @@ spec:
      imagePullSecrets:
        - name: {{ .Values.global.imagePullSecrets }}
      {{- end }}
-      terminationGracePeriodSeconds: 10
+      terminationGracePeriodSeconds: 150
      {{- if .Values.volume.priorityClassName }}
      priorityClassName: {{ .Values.volume.priorityClassName | quote }}
      {{- end }}
@@ -114,6 +114,7 @@ message Entry {
    bytes content = 9; // if not empty, the file content

    RemoteEntry remote_entry = 10;
+    int64 quota = 11; // for bucket only. Positive/Negative means enabled/disabled.
 }

 message FullEntry {
@@ -170,6 +171,8 @@ message FuseAttributes {
    string symlink_target = 13;
    bytes md5 = 14;
    string disk_type = 15;
+    uint32 rdev = 16;
+    uint64 inode = 17;
 }

 message CreateEntryRequest {
@@ -23,7 +23,7 @@
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
-            <version>2.9.2</version>
+            <version>2.10.1</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
@@ -36,7 +36,7 @@
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
-            <version>3.2.1</version>
+            <version>3.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
@@ -6,7 +6,7 @@

    <properties>
        <seaweedfs.client.version>2.85</seaweedfs.client.version>
-        <hadoop.version>2.9.2</hadoop.version>
+        <hadoop.version>2.10.1</hadoop.version>
    </properties>

    <groupId>com.github.chrislusf</groupId>
@@ -6,7 +6,7 @@

    <properties>
        <seaweedfs.client.version>2.85</seaweedfs.client.version>
-        <hadoop.version>3.1.1</hadoop.version>
+        <hadoop.version>3.1.4</hadoop.version>
    </properties>

    <groupId>com.github.chrislusf</groupId>
@@ -21,6 +21,10 @@ debug_mount:
 	go build -gcflags="all=-N -l"
 	dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec weed -- -v=4 mount -dir=~/tmp/mm -cacheCapacityMB=0 -filer.path=/ -umask=000

+debug_mount2:
+	go build -gcflags="all=-N -l"
+	dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec weed -- -v=4 mount2 -dir=~/tmp/mm -cacheCapacityMB=0 -filer.path=/ -umask=000
+
 debug_server:
 	go build -gcflags="all=-N -l"
 	dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec weed -- server -dir=~/tmp/99 -filer -volume.port=8343 -s3 -volume.max=0 -master.volumeSizeLimitMB=1024 -volume.preStopSeconds=1
@@ -96,7 +96,7 @@ func init() {
 	filerWebDavOptions.tlsPrivateKey = cmdFiler.Flag.String("webdav.key.file", "", "path to the TLS private key file")
 	filerWebDavOptions.tlsCertificate = cmdFiler.Flag.String("webdav.cert.file", "", "path to the TLS certificate file")
 	filerWebDavOptions.cacheDir = cmdFiler.Flag.String("webdav.cacheDir", os.TempDir(), "local cache directory for file chunks")
-	filerWebDavOptions.cacheSizeMB = cmdFiler.Flag.Int64("webdav.cacheCapacityMB", 1000, "local cache capacity in MB")
+	filerWebDavOptions.cacheSizeMB = cmdFiler.Flag.Int64("webdav.cacheCapacityMB", 0, "local cache capacity in MB")

 	// start iam on filer
 	filerStartIam = cmdFiler.Flag.Bool("iam", false, "whether to start IAM service")
@@ -8,7 +8,6 @@ import (
 	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
 	"github.com/chrislusf/seaweedfs/weed/wdclient"
 	"google.golang.org/grpc"
-	"math"
 	"net/url"
 	"os"
 	"strings"
@@ -115,7 +114,7 @@ func runFilerCat(cmd *Command, args []string) bool {

 		filerCat.filerClient = client

-		return filer.StreamContent(&filerCat, writer, respLookupEntry.Entry.Chunks, 0, math.MaxInt64)
+		return filer.StreamContent(&filerCat, writer, respLookupEntry.Entry.Chunks, 0, int64(filer.FileSize(respLookupEntry.Entry)))

 	})

@@ -212,7 +212,7 @@ func genFileCopyTask(fileOrDir string, destPath string, fileCopyTaskChan chan Fi
 	if mode.IsDir() {
 		files, _ := os.ReadDir(fileOrDir)
 		for _, subFileOrDir := range files {
-			cleanedDestDirectory := filepath.Clean(destPath + fi.Name())
+			cleanedDestDirectory := destPath + fi.Name()
 			if err = genFileCopyTask(fileOrDir+"/"+subFileOrDir.Name(), cleanedDestDirectory+"/", fileCopyTaskChan); err != nil {
 				return err
 			}
@@ -162,24 +162,21 @@ func (metaBackup *FilerMetaBackupOptions) streamMetadataBackup() error {
 		ctx := context.Background()
 		message := resp.EventNotification

-		if message.OldEntry == nil && message.NewEntry == nil {
+		if filer_pb.IsEmpty(resp) {
 			return nil
-		}
-		if message.OldEntry == nil && message.NewEntry != nil {
+		} else if filer_pb.IsCreate(resp) {
 			println("+", util.FullPath(message.NewParentPath).Child(message.NewEntry.Name))
 			entry := filer.FromPbEntry(message.NewParentPath, message.NewEntry)
 			return store.InsertEntry(ctx, entry)
-		}
-		if message.OldEntry != nil && message.NewEntry == nil {
+		} else if filer_pb.IsDelete(resp) {
 			println("-", util.FullPath(resp.Directory).Child(message.OldEntry.Name))
 			return store.DeleteEntry(ctx, util.FullPath(resp.Directory).Child(message.OldEntry.Name))
-		}
-		if message.OldEntry != nil && message.NewEntry != nil {
-			if resp.Directory == message.NewParentPath && message.OldEntry.Name == message.NewEntry.Name {
-				println("~", util.FullPath(message.NewParentPath).Child(message.NewEntry.Name))
-				entry := filer.FromPbEntry(message.NewParentPath, message.NewEntry)
-				return store.UpdateEntry(ctx, entry)
-			}
+		} else if filer_pb.IsUpdate(resp) {
+			println("~", util.FullPath(message.NewParentPath).Child(message.NewEntry.Name))
+			entry := filer.FromPbEntry(message.NewParentPath, message.NewEntry)
+			return store.UpdateEntry(ctx, entry)
+		} else {
+			// renaming
 			println("-", util.FullPath(resp.Directory).Child(message.OldEntry.Name))
 			if err := store.DeleteEntry(ctx, util.FullPath(resp.Directory).Child(message.OldEntry.Name)); err != nil {
 				return err
@@ -74,7 +74,7 @@ func runFilerMetaTail(cmd *Command, args []string) bool {
 	}

 	shouldPrint := func(resp *filer_pb.SubscribeMetadataResponse) bool {
-		if resp.EventNotification.OldEntry == nil && resp.EventNotification.NewEntry == nil {
+		if filer_pb.IsEmpty(resp) {
 			return false
 		}
 		if filterFunc == nil {
@@ -174,10 +174,10 @@ func (option *RemoteGatewayOptions) makeBucketedEventProcessor(filerSource *sour
 			return handleEtcRemoteChanges(resp)
 		}

-		if message.OldEntry == nil && message.NewEntry == nil {
+		if filer_pb.IsEmpty(resp) {
 			return nil
 		}
-		if message.OldEntry == nil && message.NewEntry != nil {
+		if filer_pb.IsCreate(resp) {
 			if message.NewParentPath == option.bucketsDir {
 				return handleCreateBucket(message.NewEntry)
 			}
@@ -212,7 +212,7 @@ func (option *RemoteGatewayOptions) makeBucketedEventProcessor(filerSource *sour
 			}
 			return updateLocalEntry(&remoteSyncOptions, message.NewParentPath, message.NewEntry, remoteEntry)
 		}
-		if message.OldEntry != nil && message.NewEntry == nil {
+		if filer_pb.IsDelete(resp) {
 			if resp.Directory == option.bucketsDir {
 				return handleDeleteBucket(message.OldEntry)
 			}
@@ -264,7 +264,7 @@ func (option *RemoteGatewayOptions) makeBucketedEventProcessor(filerSource *sour
 						// update directory property
 						return nil
 					}
-					if filer.IsSameData(message.OldEntry, message.NewEntry) {
+					if message.OldEntry.RemoteEntry != nil && filer.IsSameData(message.OldEntry, message.NewEntry) {
 						glog.V(2).Infof("update meta: %+v", resp)
 						oldDest := toRemoteStorageLocation(oldBucket, util.NewFullPath(resp.Directory, message.OldEntry.Name), oldRemoteStorageMountLocation)
 						return client.UpdateFileMetadata(oldDest, message.OldEntry, message.NewEntry)
@@ -91,10 +91,10 @@ func makeEventProcessor(remoteStorage *remote_pb.RemoteConf, mountedDir string,
 			return handleEtcRemoteChanges(resp)
 		}

-		if message.OldEntry == nil && message.NewEntry == nil {
+		if filer_pb.IsEmpty(resp) {
 			return nil
 		}
-		if message.OldEntry == nil && message.NewEntry != nil {
+		if filer_pb.IsCreate(resp) {
 			if !filer.HasData(message.NewEntry) {
 				return nil
 			}
@@ -115,7 +115,7 @@ func makeEventProcessor(remoteStorage *remote_pb.RemoteConf, mountedDir string,
 			}
 			return updateLocalEntry(&remoteSyncOptions, message.NewParentPath, message.NewEntry, remoteEntry)
 		}
-		if message.OldEntry != nil && message.NewEntry == nil {
+		if filer_pb.IsDelete(resp) {
 			glog.V(2).Infof("delete: %+v", resp)
 			dest := toRemoteStorageLocation(util.FullPath(mountedDir), util.NewFullPath(resp.Directory, message.OldEntry.Name), remoteStorageMountLocation)
 			if message.OldEntry.IsDirectory {
@@ -262,7 +262,7 @@ func genProcessFunction(sourcePath string, targetPath string, dataSink sink.Repl
 		}

 		// handle deletions
-		if message.OldEntry != nil && message.NewEntry == nil {
+		if filer_pb.IsDelete(resp) {
 			if !strings.HasPrefix(string(sourceOldKey), sourcePath) {
 				return nil
 			}
@@ -271,7 +271,7 @@ func genProcessFunction(sourcePath string, targetPath string, dataSink sink.Repl
 		}

 		// handle new entries
-		if message.OldEntry == nil && message.NewEntry != nil {
+		if filer_pb.IsCreate(resp) {
 			if !strings.HasPrefix(string(sourceNewKey), sourcePath) {
 				return nil
 			}
@@ -280,7 +280,7 @@ func genProcessFunction(sourcePath string, targetPath string, dataSink sink.Repl
 		}

 		// this is something special?
-		if message.OldEntry == nil && message.NewEntry == nil {
+		if filer_pb.IsEmpty(resp) {
 			return nil
 		}

@@ -2,6 +2,7 @@ package command

 import (
 	"github.com/chrislusf/raft/protobuf"
+	stats_collect "github.com/chrislusf/seaweedfs/weed/stats"
 	"github.com/gorilla/mux"
 	"google.golang.org/grpc/reflection"
 	"net/http"
@@ -42,6 +43,9 @@ type MasterOptions struct {
 	metricsAddress     *string
 	metricsIntervalSec *int
 	raftResumeState    *bool
+	metricsHttpPort    *int
+	heartbeatInterval  *time.Duration
+	electionTimeout    *time.Duration
 }

 func init() {
@@ -61,7 +65,10 @@ func init() {
 	m.disableHttp = cmdMaster.Flag.Bool("disableHttp", false, "disable http requests, only gRPC operations are allowed.")
 	m.metricsAddress = cmdMaster.Flag.String("metrics.address", "", "Prometheus gateway address <host>:<port>")
 	m.metricsIntervalSec = cmdMaster.Flag.Int("metrics.intervalSeconds", 15, "Prometheus push interval in seconds")
+	m.metricsHttpPort = cmdMaster.Flag.Int("metricsPort", 0, "Prometheus metrics listen port")
 	m.raftResumeState = cmdMaster.Flag.Bool("resumeState", false, "resume previous state on start master server")
+	m.heartbeatInterval = cmdMaster.Flag.Duration("heartbeatInterval", 300*time.Millisecond, "heartbeat interval of master servers, and will be randomly multiplied by [1, 1.25)")
+	m.electionTimeout = cmdMaster.Flag.Duration("electionTimeout", 10*time.Second, "election timeout of master servers")
 }

 var cmdMaster = &Command{
@@ -104,6 +111,7 @@ func runMaster(cmd *Command, args []string) bool {
 		glog.Fatalf("volumeSizeLimitMB should be smaller than 30000")
 	}

+	go stats_collect.StartMetricsServer(*m.metricsHttpPort)
 	startMaster(m, masterWhiteList)

 	return true
@@ -128,8 +136,17 @@ func startMaster(masterOption MasterOptions, masterWhiteList []string) {
 		glog.Fatalf("Master startup error: %v", e)
 	}
 	// start raftServer
-	raftServer, err := weed_server.NewRaftServer(security.LoadClientTLS(util.GetViper(), "grpc.master"),
-		peers, myMasterAddress, util.ResolvePath(*masterOption.metaFolder), ms.Topo, *masterOption.raftResumeState)
+	raftServerOption := &weed_server.RaftServerOption{
+		GrpcDialOption:    security.LoadClientTLS(util.GetViper(), "grpc.master"),
+		Peers:             peers,
+		ServerAddr:        myMasterAddress,
+		DataDir:           util.ResolvePath(*masterOption.metaFolder),
+		Topo:              ms.Topo,
+		RaftResumeState:   *masterOption.raftResumeState,
+		HeartbeatInterval: *masterOption.heartbeatInterval,
+		ElectionTimeout:   *masterOption.electionTimeout,
+	}
+	raftServer, err := weed_server.NewRaftServer(raftServerOption)
 	if raftServer == nil {
 		glog.Fatalf("please verify %s is writable, see https://github.com/chrislusf/seaweedfs/issues/717: %s", *masterOption.metaFolder, err)
 	}
@@ -50,7 +50,7 @@ func init() {
 	mountOptions.chunkSizeLimitMB = cmdMount.Flag.Int("chunkSizeLimitMB", 2, "local write buffer size, also chunk large files")
 	mountOptions.concurrentWriters = cmdMount.Flag.Int("concurrentWriters", 32, "limit concurrent goroutine writers if not 0")
 	mountOptions.cacheDir = cmdMount.Flag.String("cacheDir", os.TempDir(), "local cache directory for file chunks and meta data")
-	mountOptions.cacheSizeMB = cmdMount.Flag.Int64("cacheCapacityMB", 1000, "local file chunk cache capacity in MB (0 will disable cache)")
+	mountOptions.cacheSizeMB = cmdMount.Flag.Int64("cacheCapacityMB", 0, "local file chunk cache capacity in MB")
 	mountOptions.dataCenter = cmdMount.Flag.String("dataCenter", "", "prefer to write to the data center")
 	mountOptions.allowOthers = cmdMount.Flag.Bool("allowOthers", true, "allows other users to access the file system")
 	mountOptions.umaskString = cmdMount.Flag.String("umask", "022", "octal umask, e.g., 022, 0111")
@@ -1,13 +1,5 @@
 package command

-import (
-	"github.com/seaweedfs/fuse"
-)
-
-func osSpecificMountOptions() []fuse.MountOption {
-	return []fuse.MountOption{}
-}
-
 func checkMountPointAvailable(dir string) bool {
 	return true
 }
@@ -1,13 +0,0 @@
-package command
-
-import (
-	"github.com/seaweedfs/fuse"
-)
-
-func osSpecificMountOptions() []fuse.MountOption {
-	return []fuse.MountOption{}
-}
-
-func checkMountPointAvailable(dir string) bool {
-	return true
-}
@@ -6,8 +6,6 @@ import (
 	"io"
 	"os"
 	"strings"
-
-	"github.com/seaweedfs/fuse"
 )

 const (
@@ -137,10 +135,6 @@ func parseInfoFile(r io.Reader) ([]*Info, error) {
 	return out, nil
 }

-func osSpecificMountOptions() []fuse.MountOption {
-	return []fuse.MountOption{}
-}
-
 func checkMountPointAvailable(dir string) bool {
 	mountPoint := dir
 	if mountPoint != "/" && strings.HasSuffix(mountPoint, "/") {
@@ -1,5 +1,5 @@
-//go:build !linux && !darwin && !freebsd
-// +build !linux,!darwin,!freebsd
+//go:build !linux && !darwin
+// +build !linux,!darwin

 package command

@@ -1,34 +1,28 @@
-//go:build linux || darwin || freebsd
-// +build linux darwin freebsd
+//go:build linux || darwin
+// +build linux darwin

 package command

 import (
 	"context"
 	"fmt"
-	"net/http"
-	"os"
-	"os/user"
-	"path"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/chrislusf/seaweedfs/weed/storage/types"
-
-	"github.com/chrislusf/seaweedfs/weed/filesys/meta_cache"
-
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-
-	"github.com/chrislusf/seaweedfs/weed/filesys"
 	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/mount"
+	"github.com/chrislusf/seaweedfs/weed/mount/meta_cache"
+	"github.com/chrislusf/seaweedfs/weed/mount/unmount"
 	"github.com/chrislusf/seaweedfs/weed/pb"
 	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
 	"github.com/chrislusf/seaweedfs/weed/security"
+	"github.com/chrislusf/seaweedfs/weed/storage/types"
+	"github.com/hanwen/go-fuse/v2/fuse"
+	"net/http"
+	"os"
+	"os/user"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+
 	"github.com/chrislusf/seaweedfs/weed/util"
 	"github.com/chrislusf/seaweedfs/weed/util/grace"
 )
@@ -55,30 +49,21 @@ func runMount(cmd *Command, args []string) bool {
 		return false
 	}

-	return RunMount(&mountOptions, os.FileMode(umask))
+	return RunMount2(&mountOptions, os.FileMode(umask))
 }

-func getParentInode(mountDir string) (uint64, error) {
-	parentDir := filepath.Clean(filepath.Join(mountDir, ".."))
-	fi, err := os.Stat(parentDir)
-	if err != nil {
-		return 0, err
+func RunMount2(option *MountOptions, umask os.FileMode) bool {
+
+	// basic checks
+	chunkSizeLimitMB := *mountOptions.chunkSizeLimitMB
+	if chunkSizeLimitMB <= 0 {
+		fmt.Printf("Please specify a reasonable buffer size.")
+		return false
 	}

-	stat, ok := fi.Sys().(*syscall.Stat_t)
-	if !ok {
-		return 0, nil
-	}
-
-	return stat.Ino, nil
-}
-
-func RunMount(option *MountOptions, umask os.FileMode) bool {
-
+	// try to connect to filer
 	filerAddresses := pb.ServerAddresses(*option.filer).ToAddresses()
-
 	util.LoadConfiguration("security", false)
-	// try to connect to filer, filerBucketsPath may be useful later
 	grpcDialOption := security.LoadClientTLS(util.GetViper(), "grpc.client")
 	var cipher bool
 	var err error
@@ -103,26 +88,15 @@ func RunMount(option *MountOptions, umask os.FileMode) bool {
 	}

 	filerMountRootPath := *option.filerMountRootPath
-	dir := util.ResolvePath(*option.dir)
-	parentInode, err := getParentInode(dir)
-	if err != nil {
-		glog.Errorf("failed to retrieve inode for parent directory of %s: %v", dir, err)
-		return true
-	}

-	fmt.Printf("This is SeaweedFS version %s %s %s\n", util.Version(), runtime.GOOS, runtime.GOARCH)
+	// clean up mount point
+	dir := util.ResolvePath(*option.dir)
 	if dir == "" {
 		fmt.Printf("Please specify the mount directory via \"-dir\"")
 		return false
 	}

-	chunkSizeLimitMB := *mountOptions.chunkSizeLimitMB
-	if chunkSizeLimitMB <= 0 {
-		fmt.Printf("Please specify a reasonable buffer size.")
-		return false
-	}
-
-	fuse.Unmount(dir)
+	unmount.Unmount(dir)

 	// detect mount folder mode
 	if *option.dirAutoCreate {
@@ -130,6 +104,7 @@ func RunMount(option *MountOptions, umask os.FileMode) bool {
 	}
 	fileInfo, err := os.Stat(dir)

+	// collect uid, gid
 	uid, gid := uint32(0), uint32(0)
 	mountMode := os.ModeDir | 0777
 	if err == nil {
@@ -141,6 +116,7 @@ func RunMount(option *MountOptions, umask os.FileMode) bool {
 		return false
 	}

+	// detect uid, gid
 	if uid == 0 {
 		if u, err := user.Current(); err == nil {
 			if parsedId, pe := strconv.ParseUint(u.Uid, 10, 32); pe == nil {
@@ -166,35 +142,49 @@ func RunMount(option *MountOptions, umask os.FileMode) bool {
 		return true
 	}

-	mountName := path.Base(dir)
-
-	options := []fuse.MountOption{
-		fuse.VolumeName(mountName),
-		fuse.FSName(*option.filer + ":" + filerMountRootPath),
-		fuse.Subtype("seaweedfs"),
-		// fuse.NoAppleDouble(), // include .DS_Store, otherwise can not delete non-empty folders
-		fuse.NoAppleXattr(),
-		fuse.ExclCreate(),
-		fuse.DaemonTimeout("3600"),
-		fuse.AllowDev(),
-		fuse.AllowSUID(),
-		fuse.DefaultPermissions(),
-		fuse.MaxReadahead(1024 * 512),
-		fuse.AsyncRead(),
-		// fuse.WritebackCache(),
-		// fuse.MaxBackground(1024),
-		// fuse.CongestionThreshold(1024),
-	}
-
-	options = append(options, osSpecificMountOptions()...)
-	if *option.allowOthers {
-		options = append(options, fuse.AllowOther())
+	// mount fuse
+	fuseMountOptions := &fuse.MountOptions{
+		AllowOther:               *option.allowOthers,
+		Options:                  nil,
+		MaxBackground:            128,
+		MaxWrite:                 1024 * 1024 * 2,
+		MaxReadAhead:             1024 * 1024 * 2,
+		IgnoreSecurityLabels:     false,
+		RememberInodes:           false,
+		FsName:                   *option.filer + ":" + filerMountRootPath,
+		Name:                     "seaweedfs",
+		SingleThreaded:           false,
+		DisableXAttrs:            false,
+		Debug:                    *option.debug,
+		EnableLocks:              false,
+		ExplicitDataCacheControl: false,
+		DirectMount:              true,
+		DirectMountFlags:         0,
+		//SyncRead:                 false, // set to false to enable the FUSE_CAP_ASYNC_READ capability
+		//EnableAcl:                true,
 	}
 	if *option.nonempty {
-		options = append(options, fuse.AllowNonEmptyMount())
+		fuseMountOptions.Options = append(fuseMountOptions.Options, "nonempty")
 	}
 	if *option.readOnly {
-		options = append(options, fuse.ReadOnly())
+		if runtime.GOOS == "darwin" {
+			fuseMountOptions.Options = append(fuseMountOptions.Options, "rdonly")
+		} else {
+			fuseMountOptions.Options = append(fuseMountOptions.Options, "ro")
+		}
+	}
+	if runtime.GOOS == "darwin" {
+		// https://github-wiki-see.page/m/macfuse/macfuse/wiki/Mount-Options
+		ioSizeMB := 1
+		for ioSizeMB*2 <= *option.chunkSizeLimitMB && ioSizeMB*2 <= 32 {
+			ioSizeMB *= 2
+		}
+		fuseMountOptions.Options = append(fuseMountOptions.Options, "daemon_timeout=600")
+		fuseMountOptions.Options = append(fuseMountOptions.Options, "noapplexattr")
+		// fuseMountOptions.Options = append(fuseMountOptions.Options, "novncache") // need to test effectiveness
+		fuseMountOptions.Options = append(fuseMountOptions.Options, "slow_statfs")
+		fuseMountOptions.Options = append(fuseMountOptions.Options, "volname="+*option.filer)
+		fuseMountOptions.Options = append(fuseMountOptions.Options, fmt.Sprintf("iosize=%d", ioSizeMB*1024*1024))
 	}

 	// find mount point
@@ -203,9 +193,7 @@ func RunMount(option *MountOptions, umask os.FileMode) bool {
 		mountRoot = mountRoot[0 : len(mountRoot)-1]
 	}

-	diskType := types.ToDiskType(*option.diskType)
-
-	seaweedFileSystem := filesys.NewSeaweedFileSystem(&filesys.Option{
+	seaweedFileSystem := mount.NewSeaweedFileSystem(&mount.Option{
 		MountDirectory:     dir,
 		FilerAddresses:     filerAddresses,
 		GrpcDialOption:     grpcDialOption,
@@ -213,7 +201,7 @@ func RunMount(option *MountOptions, umask os.FileMode) bool {
 		Collection:         *option.collection,
 		Replication:        *option.replication,
 		TtlSec:             int32(*option.ttlSec),
-		DiskType:           diskType,
+		DiskType:           types.ToDiskType(*option.diskType),
 		ChunkSizeLimit:     int64(chunkSizeLimitMB) * 1024 * 1024,
 		ConcurrentWriters:  *option.concurrentWriters,
 		CacheDir:           *option.cacheDir,
@@ -224,38 +212,25 @@ func RunMount(option *MountOptions, umask os.FileMode) bool {
 		MountMode:          mountMode,
 		MountCtime:         fileInfo.ModTime(),
 		MountMtime:         time.Now(),
-		MountParentInode:   parentInode,
 		Umask:              umask,
 		VolumeServerAccess: *mountOptions.volumeServerAccess,
 		Cipher:             cipher,
 		UidGidMapper:       uidGidMapper,
 	})

-	// mount
-	c, err := fuse.Mount(dir, options...)
+	server, err := fuse.NewServer(seaweedFileSystem, dir, fuseMountOptions)
 	if err != nil {
-		glog.V(0).Infof("mount: %v", err)
-		return true
+		glog.Fatalf("Mount fail: %v", err)
 	}
-	defer fuse.Unmount(dir)
-
 	grace.OnInterrupt(func() {
-		fuse.Unmount(dir)
-		c.Close()
+		unmount.Unmount(dir)
 	})

-	glog.V(0).Infof("mounted %s%s to %v", *option.filer, mountRoot, dir)
-	server := fs.New(c, nil)
-	seaweedFileSystem.Server = server
 	seaweedFileSystem.StartBackgroundTasks()
-	err = server.Serve(seaweedFileSystem)

-	// check if the mount process has an error to report
-	<-c.Ready
-	if err := c.MountError; err != nil {
-		glog.V(0).Infof("mount process: %v", err)
-		return true
-	}
+	fmt.Printf("This is SeaweedFS version %s %s %s\n", util.Version(), runtime.GOOS, runtime.GOARCH)
+
+	server.Serve()

 	return true
 }
@@ -2,7 +2,7 @@ package command

 import (
 	"fmt"
-	"os"
+	"github.com/chrislusf/seaweedfs/weed/util"
 	"path/filepath"

 	"github.com/chrislusf/seaweedfs/weed/command/scaffold"
@@ -56,7 +56,7 @@ func runScaffold(cmd *Command, args []string) bool {
 	}

 	if *outputPath != "" {
-		os.WriteFile(filepath.Join(*outputPath, *config+".toml"), []byte(content), 0644)
+		util.WriteFile(filepath.Join(*outputPath, *config+".toml"), []byte(content), 0644)
 	} else {
 		fmt.Println(content)
 	}
@@ -195,6 +195,40 @@ routeByLatency = false
 # This changes the data layout. Only add new directories. Removing/Updating will cause data loss.
 superLargeDirectories = []

+[redis_lua]
+enabled = false
+address = "localhost:6379"
+password = ""
+database = 0
+# This changes the data layout. Only add new directories. Removing/Updating will cause data loss.
+superLargeDirectories = []
+
+[redis_lua_sentinel]
+enabled = false
+addresses = ["172.22.12.7:26379","172.22.12.8:26379","172.22.12.9:26379"]
+masterName = "master"
+username = ""
+password = ""
+database = 0
+
+[redis_lua_cluster]
+enabled = false
+addresses = [
+    "localhost:30001",
+    "localhost:30002",
+    "localhost:30003",
+    "localhost:30004",
+    "localhost:30005",
+    "localhost:30006",
+]
+password = ""
+# allows reads from slave servers or the master, but all writes still go to the master
+readOnly = false
+# automatically use the closest Redis server for reads
+routeByLatency = false
+# This changes the data layout. Only add new directories. Removing/Updating will cause data loss.
+superLargeDirectories = []
+
 [redis3] # beta
 enabled = false
 address = "localhost:6379"
@@ -98,6 +98,8 @@ func init() {
 	masterOptions.metricsAddress = cmdServer.Flag.String("metrics.address", "", "Prometheus gateway address")
 	masterOptions.metricsIntervalSec = cmdServer.Flag.Int("metrics.intervalSeconds", 15, "Prometheus push interval in seconds")
 	masterOptions.raftResumeState = cmdServer.Flag.Bool("resumeState", false, "resume previous state on start master server")
+	masterOptions.heartbeatInterval = cmdServer.Flag.Duration("master.heartbeatInterval", 300*time.Millisecond, "heartbeat interval of master servers, and will be randomly multiplied by [1, 1.25)")
+	masterOptions.electionTimeout = cmdServer.Flag.Duration("master.electionTimeout", 10*time.Second, "election timeout of master servers")

 	filerOptions.collection = cmdServer.Flag.String("filer.collection", "", "all data will be stored in this collection")
 	filerOptions.port = cmdServer.Flag.Int("filer.port", 8888, "filer server http listen port")
@@ -145,7 +147,7 @@ func init() {
 	webdavOptions.tlsPrivateKey = cmdServer.Flag.String("webdav.key.file", "", "path to the TLS private key file")
 	webdavOptions.tlsCertificate = cmdServer.Flag.String("webdav.cert.file", "", "path to the TLS certificate file")
 	webdavOptions.cacheDir = cmdServer.Flag.String("webdav.cacheDir", os.TempDir(), "local cache directory for file chunks")
-	webdavOptions.cacheSizeMB = cmdServer.Flag.Int64("webdav.cacheCapacityMB", 1000, "local cache capacity in MB")
+	webdavOptions.cacheSizeMB = cmdServer.Flag.Int64("webdav.cacheCapacityMB", 0, "local cache capacity in MB")

 	msgBrokerOptions.port = cmdServer.Flag.Int("msgBroker.port", 17777, "broker gRPC listen port")

@@ -188,6 +190,7 @@ func runServer(cmd *Command, args []string) bool {
 	filerOptions.ip = serverIp
 	filerOptions.bindIp = serverBindIp
 	s3Options.bindIp = serverBindIp
+	iamOptions.masters = masterOptions.peers
 	serverOptions.v.ip = serverIp
 	serverOptions.v.bindIp = serverBindIp
 	serverOptions.v.masters = pb.ServerAddresses(*masterOptions.peers).ToAddresses()
@@ -94,7 +94,7 @@ func init() {
 	v.pprof = cmdVolume.Flag.Bool("pprof", false, "enable pprof http handlers. precludes --memprofile and --cpuprofile")
 	v.metricsHttpPort = cmdVolume.Flag.Int("metricsPort", 0, "Prometheus metrics listen port")
 	v.idxFolder = cmdVolume.Flag.String("dir.idx", "", "directory to store .idx files")
-	v.enableTcp = cmdVolume.Flag.Bool("tcp", false, "<exprimental> enable tcp port")
+	v.enableTcp = cmdVolume.Flag.Bool("tcp", false, "<experimental> enable tcp port")
 }

 var cmdVolume = &Command{
@@ -364,8 +364,8 @@ func (v VolumeServerOptions) startClusterHttpService(handler http.Handler) httpd
 	}

 	httpDown := httpdown.HTTP{
-		KillTimeout: 5 * time.Minute,
-		StopTimeout: 5 * time.Minute,
+		KillTimeout: time.Minute,
+		StopTimeout: 30 * time.Second,
 		CertFile:    certFile,
 		KeyFile:     keyFile}
 	clusterHttpServer := httpDown.Serve(&http.Server{Handler: handler}, listener)
@@ -43,7 +43,7 @@ func init() {
 	webDavStandaloneOptions.tlsPrivateKey = cmdWebDav.Flag.String("key.file", "", "path to the TLS private key file")
 	webDavStandaloneOptions.tlsCertificate = cmdWebDav.Flag.String("cert.file", "", "path to the TLS certificate file")
 	webDavStandaloneOptions.cacheDir = cmdWebDav.Flag.String("cacheDir", os.TempDir(), "local cache directory for file chunks")
-	webDavStandaloneOptions.cacheSizeMB = cmdWebDav.Flag.Int64("cacheCapacityMB", 1000, "local cache capacity in MB")
+	webDavStandaloneOptions.cacheSizeMB = cmdWebDav.Flag.Int64("cacheCapacityMB", 0, "local cache capacity in MB")
 }

 var cmdWebDav = &Command{
@@ -24,6 +24,8 @@ type Attr struct {
 	SymlinkTarget string
 	Md5           []byte
 	FileSize      uint64
+	Rdev          uint32
+	Inode         uint64
 }

 func (attr Attr) IsDirectory() bool {
@@ -43,6 +45,7 @@ type Entry struct {
 	HardLinkCounter int32
 	Content         []byte
 	Remote          *filer_pb.RemoteEntry
+	Quota           int64
 }

 func (entry *Entry) Size() uint64 {
@@ -70,6 +73,7 @@ func (entry *Entry) ShallowClone() *Entry {
 	newEntry.HardLinkCounter = entry.HardLinkCounter
 	newEntry.Content = entry.Content
 	newEntry.Remote = entry.Remote
+	newEntry.Quota = entry.Quota

 	return newEntry
 }
@@ -96,6 +100,7 @@ func (entry *Entry) ToExistingProtoEntry(message *filer_pb.Entry) {
 	message.HardLinkCounter = entry.HardLinkCounter
 	message.Content = entry.Content
 	message.RemoteEntry = entry.Remote
+	message.Quota = entry.Quota
 }

 func FromPbEntryToExistingEntry(message *filer_pb.Entry, fsEntry *Entry) {
@@ -106,6 +111,7 @@ func FromPbEntryToExistingEntry(message *filer_pb.Entry, fsEntry *Entry) {
 	fsEntry.HardLinkCounter = message.HardLinkCounter
 	fsEntry.Content = message.Content
 	fsEntry.Remote = message.RemoteEntry
+	fsEntry.Quota = message.Quota
 }

 func (entry *Entry) ToProtoFullEntry() *filer_pb.FullEntry {
@@ -48,6 +48,8 @@ func EntryAttributeToPb(entry *Entry) *filer_pb.FuseAttributes {
 		SymlinkTarget: entry.Attr.SymlinkTarget,
 		Md5:           entry.Attr.Md5,
 		FileSize:      entry.Attr.FileSize,
+		Rdev:          entry.Attr.Rdev,
+		Inode:         entry.Attr.Inode,
 	}
 }

@@ -74,6 +76,8 @@ func PbToEntryAttribute(attr *filer_pb.FuseAttributes) Attr {
 	t.SymlinkTarget = attr.SymlinkTarget
 	t.Md5 = attr.Md5
 	t.FileSize = attr.FileSize
+	t.Rdev = attr.Rdev
+	t.Inode = attr.Inode

 	return t
 }
@@ -118,6 +122,9 @@ func EqualEntry(a, b *Entry) bool {
 	if !proto.Equal(a.Remote, b.Remote) {
 		return false
 	}
+	if a.Quota != b.Quota {
+		return false
+	}
 	return true
 }

@@ -3,6 +3,7 @@ package filer
 import (
 	"bytes"
 	"fmt"
+	"github.com/chrislusf/seaweedfs/weed/util/mem"
 	"github.com/chrislusf/seaweedfs/weed/wdclient"
 	"io"
 	"math"
@@ -77,7 +78,9 @@ func ResolveOneChunkManifest(lookupFileIdFn wdclient.LookupFileIdFunctionType, c
 	}

 	// IsChunkManifest
-	data, err := fetchChunk(lookupFileIdFn, chunk.GetFileIdString(), chunk.CipherKey, chunk.IsCompressed)
+	data := mem.Allocate(int(chunk.Size))
+	defer mem.Free(data)
+	_, err := fetchChunk(data, lookupFileIdFn, chunk.GetFileIdString(), chunk.CipherKey, chunk.IsCompressed)
 	if err != nil {
 		return nil, fmt.Errorf("fail to read manifest %s: %v", chunk.GetFileIdString(), err)
 	}
@@ -92,38 +95,30 @@ func ResolveOneChunkManifest(lookupFileIdFn wdclient.LookupFileIdFunctionType, c
 }

 // TODO fetch from cache for weed mount?
-func fetchChunk(lookupFileIdFn wdclient.LookupFileIdFunctionType, fileId string, cipherKey []byte, isGzipped bool) ([]byte, error) {
+func fetchChunk(data []byte, lookupFileIdFn wdclient.LookupFileIdFunctionType, fileId string, cipherKey []byte, isGzipped bool) (int, error) {
 	urlStrings, err := lookupFileIdFn(fileId)
 	if err != nil {
 		glog.Errorf("operation LookupFileId %s failed, err: %v", fileId, err)
-		return nil, err
+		return 0, err
 	}
-	return retriedFetchChunkData(urlStrings, cipherKey, isGzipped, true, 0, 0)
+	return retriedFetchChunkData(data, urlStrings, cipherKey, isGzipped, true, 0)
 }

-func fetchChunkRange(lookupFileIdFn wdclient.LookupFileIdFunctionType, fileId string, cipherKey []byte, isGzipped bool, offset int64, size int) ([]byte, error) {
-	urlStrings, err := lookupFileIdFn(fileId)
-	if err != nil {
-		glog.Errorf("operation LookupFileId %s failed, err: %v", fileId, err)
-		return nil, err
-	}
-	return retriedFetchChunkData(urlStrings, cipherKey, isGzipped, false, offset, size)
-}
+func retriedFetchChunkData(buffer []byte, urlStrings []string, cipherKey []byte, isGzipped bool, isFullChunk bool, offset int64) (n int, err error) {

-func retriedFetchChunkData(urlStrings []string, cipherKey []byte, isGzipped bool, isFullChunk bool, offset int64, size int) ([]byte, error) {
-
-	var err error
 	var shouldRetry bool
-	receivedData := make([]byte, 0, size)

 	for waitTime := time.Second; waitTime < util.RetryWaitTime; waitTime += waitTime / 2 {
 		for _, urlString := range urlStrings {
-			receivedData = receivedData[:0]
+			n = 0
 			if strings.Contains(urlString, "%") {
 				urlString = url.PathEscape(urlString)
 			}
-			shouldRetry, err = util.ReadUrlAsStream(urlString+"?readDeleted=true", cipherKey, isGzipped, isFullChunk, offset, size, func(data []byte) {
-				receivedData = append(receivedData, data...)
+			shouldRetry, err = util.ReadUrlAsStream(urlString+"?readDeleted=true", cipherKey, isGzipped, isFullChunk, offset, len(buffer), func(data []byte) {
+				if n < len(buffer) {
+					x := copy(buffer[n:], data)
+					n += x
+				}
 			})
 			if !shouldRetry {
 				break
@@ -142,7 +137,7 @@ func retriedFetchChunkData(urlStrings []string, cipherKey []byte, isGzipped bool
 		}
 	}

-	return receivedData, err
+	return n, err

 }

@@ -101,6 +101,21 @@ func DoMinusChunks(as, bs []*filer_pb.FileChunk) (delta []*filer_pb.FileChunk) {
 	return
 }

+func DoMinusChunksBySourceFileId(as, bs []*filer_pb.FileChunk) (delta []*filer_pb.FileChunk) {
+
+	fileIds := make(map[string]bool)
+	for _, interval := range bs {
+		fileIds[interval.GetFileIdString()] = true
+	}
+	for _, chunk := range as {
+		if _, found := fileIds[chunk.GetSourceFileId()]; !found {
+			delta = append(delta, chunk)
+		}
+	}
+
+	return
+}
+
 type ChunkView struct {
 	FileId      string
 	Offset      int64
@@ -75,12 +75,12 @@ func (fc *FilerConf) loadFromFiler(filer *Filer) (err error) {
 		return fc.LoadFromBytes(entry.Content)
 	}

-	return fc.loadFromChunks(filer, entry.Content, entry.Chunks)
+	return fc.loadFromChunks(filer, entry.Content, entry.Chunks, entry.Size())
 }

-func (fc *FilerConf) loadFromChunks(filer *Filer, content []byte, chunks []*filer_pb.FileChunk) (err error) {
+func (fc *FilerConf) loadFromChunks(filer *Filer, content []byte, chunks []*filer_pb.FileChunk, size uint64) (err error) {
 	if len(content) == 0 {
-		content, err = filer.readEntry(chunks)
+		content, err = filer.readEntry(chunks, size)
 		if err != nil {
 			glog.Errorf("read filer conf content: %v", err)
 			return
@@ -9,8 +9,6 @@ import (
 	"github.com/chrislusf/seaweedfs/weed/util"
 )

-type HardLinkId []byte
-
 const (
 	MsgFailDelNonEmptyFolder = "fail to delete non-empty folder"
 )
@@ -127,7 +125,11 @@ func (f *Filer) doDeleteEntryMetaAndData(ctx context.Context, entry *Entry, shou

 	glog.V(3).Infof("deleting entry %v, delete chunks: %v", entry.FullPath, shouldDeleteChunks)

-	if storeDeletionErr := f.Store.DeleteOneEntry(ctx, entry); storeDeletionErr != nil {
+	if !entry.IsDirectory() && !shouldDeleteChunks {
+		if storeDeletionErr := f.Store.DeleteOneEntrySkipHardlink(ctx, entry.FullPath); storeDeletionErr != nil {
+			return fmt.Errorf("filer store delete skip hardlink: %v", storeDeletionErr)
+		}
+	} else if storeDeletionErr := f.Store.DeleteOneEntry(ctx, entry); storeDeletionErr != nil {
 		return fmt.Errorf("filer store delete: %v", storeDeletionErr)
 	}
 	if !entry.IsDirectory() {
@@ -0,0 +1,16 @@
+package filer
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/util"
+)
+
+const (
+	HARD_LINK_MARKER = '\x01'
+)
+
+type HardLinkId []byte // 16 bytes + 1 marker byte
+
+func NewHardLinkId() HardLinkId {
+	bytes := append(util.RandomBytes(16), HARD_LINK_MARKER)
+	return bytes
+}
@@ -2,8 +2,6 @@ package filer

 import (
 	"bytes"
-	"math"
-
 	"github.com/chrislusf/seaweedfs/weed/glog"
 	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
 	"github.com/chrislusf/seaweedfs/weed/util"
@@ -24,12 +22,12 @@ func (f *Filer) onBucketEvents(event *filer_pb.SubscribeMetadataResponse) {
 		}
 	}
 	if f.DirBucketsPath == event.Directory {
-		if message.OldEntry == nil && message.NewEntry != nil {
+		if filer_pb.IsCreate(event) {
 			if message.NewEntry.IsDirectory {
 				f.Store.OnBucketCreation(message.NewEntry.Name)
 			}
 		}
-		if message.OldEntry != nil && message.NewEntry == nil {
+		if filer_pb.IsDelete(event) {
 			if message.OldEntry.IsDirectory {
 				f.Store.OnBucketDeletion(message.OldEntry.Name)
 			}
@@ -55,9 +53,9 @@ func (f *Filer) maybeReloadFilerConfiguration(event *filer_pb.SubscribeMetadataR
 	}
 }

-func (f *Filer) readEntry(chunks []*filer_pb.FileChunk) ([]byte, error) {
+func (f *Filer) readEntry(chunks []*filer_pb.FileChunk, size uint64) ([]byte, error) {
 	var buf bytes.Buffer
-	err := StreamContent(f.MasterClient, &buf, chunks, 0, math.MaxInt64)
+	err := StreamContent(f.MasterClient, &buf, chunks, 0, int64(size))
 	if err != nil {
 		return nil, err
 	}
@@ -66,7 +64,7 @@ func (f *Filer) readEntry(chunks []*filer_pb.FileChunk) ([]byte, error) {

 func (f *Filer) reloadFilerConfiguration(entry *filer_pb.Entry) {
 	fc := NewFilerConf()
-	err := fc.loadFromChunks(f, entry.Content, entry.Chunks)
+	err := fc.loadFromChunks(f, entry.Content, entry.Chunks, FileSize(entry))
 	if err != nil {
 		glog.Errorf("read filer conf chunks: %v", err)
 		return
@@ -9,16 +9,20 @@ import (
 )

 func (fsw *FilerStoreWrapper) handleUpdateToHardLinks(ctx context.Context, entry *Entry) error {
-	if len(entry.HardLinkId) == 0 {
+
+	if entry.IsDirectory() {
 		return nil
 	}
-	// handle hard links
-	if err := fsw.setHardLink(ctx, entry); err != nil {
-		return fmt.Errorf("setHardLink %d: %v", entry.HardLinkId, err)
+
+	if len(entry.HardLinkId) > 0 {
+		// handle hard links
+		if err := fsw.setHardLink(ctx, entry); err != nil {
+			return fmt.Errorf("setHardLink %d: %v", entry.HardLinkId, err)
+		}
 	}

 	// check what is existing entry
-	glog.V(4).Infof("handleUpdateToHardLinks FindEntry %s", entry.FullPath)
+	// glog.V(4).Infof("handleUpdateToHardLinks FindEntry %s", entry.FullPath)
 	actualStore := fsw.getActualStore(entry.FullPath)
 	existingEntry, err := actualStore.FindEntry(ctx, entry.FullPath)
 	if err != nil && err != filer_pb.ErrNotFound {
@@ -46,6 +50,8 @@ func (fsw *FilerStoreWrapper) setHardLink(ctx context.Context, entry *Entry) err
 		return encodeErr
 	}

+	glog.V(4).Infof("setHardLink %v nlink:%d", entry.FullPath, entry.HardLinkCounter)
+
 	return fsw.KvPut(ctx, key, newBlob)
 }

@@ -55,7 +61,6 @@ func (fsw *FilerStoreWrapper) maybeReadHardLink(ctx context.Context, entry *Entr
 	}
 	key := entry.HardLinkId

-	glog.V(4).Infof("maybeReadHardLink KvGet %v", key)
 	value, err := fsw.KvGet(ctx, key)
 	if err != nil {
 		glog.Errorf("read %s hardlink %d: %v", entry.FullPath, entry.HardLinkId, err)
@@ -67,6 +72,8 @@ func (fsw *FilerStoreWrapper) maybeReadHardLink(ctx context.Context, entry *Entr
 		return err
 	}

+	glog.V(4).Infof("maybeReadHardLink %v nlink:%d", entry.FullPath, entry.HardLinkCounter)
+
 	return nil
 }

@@ -23,6 +23,7 @@ type VirtualFilerStore interface {
 	FilerStore
 	DeleteHardLink(ctx context.Context, hardLinkId HardLinkId) error
 	DeleteOneEntry(ctx context.Context, entry *Entry) error
+	DeleteOneEntrySkipHardlink(ctx context.Context, fullpath util.FullPath) error
 	AddPathSpecificStore(path string, storeId string, store FilerStore)
 	OnBucketCreation(bucket string)
 	OnBucketDeletion(bucket string)
@@ -127,7 +128,7 @@ func (fsw *FilerStoreWrapper) InsertEntry(ctx context.Context, entry *Entry) err
 		return err
 	}

-	glog.V(4).Infof("InsertEntry %s", entry.FullPath)
+	// glog.V(4).Infof("InsertEntry %s", entry.FullPath)
 	return actualStore.InsertEntry(ctx, entry)
 }

@@ -148,7 +149,7 @@ func (fsw *FilerStoreWrapper) UpdateEntry(ctx context.Context, entry *Entry) err
 		return err
 	}

-	glog.V(4).Infof("UpdateEntry %s", entry.FullPath)
+	// glog.V(4).Infof("UpdateEntry %s", entry.FullPath)
 	return actualStore.UpdateEntry(ctx, entry)
 }

@@ -192,7 +193,7 @@ func (fsw *FilerStoreWrapper) DeleteEntry(ctx context.Context, fp util.FullPath)
 		}
 	}

-	glog.V(4).Infof("DeleteEntry %s", fp)
+	// glog.V(4).Infof("DeleteEntry %s", fp)
 	return actualStore.DeleteEntry(ctx, fp)
 }

@@ -212,10 +213,22 @@ func (fsw *FilerStoreWrapper) DeleteOneEntry(ctx context.Context, existingEntry
 		}
 	}

-	glog.V(4).Infof("DeleteOneEntry %s", existingEntry.FullPath)
+	// glog.V(4).Infof("DeleteOneEntry %s", existingEntry.FullPath)
 	return actualStore.DeleteEntry(ctx, existingEntry.FullPath)
 }

+func (fsw *FilerStoreWrapper) DeleteOneEntrySkipHardlink(ctx context.Context, fullpath util.FullPath) (err error) {
+	actualStore := fsw.getActualStore(fullpath)
+	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "delete").Inc()
+	start := time.Now()
+	defer func() {
+		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "delete").Observe(time.Since(start).Seconds())
+	}()
+
+	glog.V(4).Infof("DeleteOneEntrySkipHardlink %s", fullpath)
+	return actualStore.DeleteEntry(ctx, fullpath)
+}
+
 func (fsw *FilerStoreWrapper) DeleteFolderChildren(ctx context.Context, fp util.FullPath) (err error) {
 	actualStore := fsw.getActualStore(fp + "/")
 	stats.FilerStoreCounter.WithLabelValues(actualStore.GetName(), "deleteFolderChildren").Inc()
@@ -224,7 +237,7 @@ func (fsw *FilerStoreWrapper) DeleteFolderChildren(ctx context.Context, fp util.
 		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "deleteFolderChildren").Observe(time.Since(start).Seconds())
 	}()

-	glog.V(4).Infof("DeleteFolderChildren %s", fp)
+	// glog.V(4).Infof("DeleteFolderChildren %s", fp)
 	return actualStore.DeleteFolderChildren(ctx, fp)
 }

@@ -236,7 +249,7 @@ func (fsw *FilerStoreWrapper) ListDirectoryEntries(ctx context.Context, dirPath
 		stats.FilerStoreHistogram.WithLabelValues(actualStore.GetName(), "list").Observe(time.Since(start).Seconds())
 	}()

-	glog.V(4).Infof("ListDirectoryEntries %s from %s limit %d", dirPath, startFileName, limit)
+	// glog.V(4).Infof("ListDirectoryEntries %s from %s limit %d", dirPath, startFileName, limit)
 	return actualStore.ListDirectoryEntries(ctx, dirPath, startFileName, includeStartFile, limit, func(entry *Entry) bool {
 		fsw.maybeReadHardLink(ctx, entry)
 		filer_pb.AfterEntryDeserialization(entry.Chunks)
@@ -254,7 +267,7 @@ func (fsw *FilerStoreWrapper) ListDirectoryPrefixedEntries(ctx context.Context,
 	if limit > math.MaxInt32-1 {
 		limit = math.MaxInt32 - 1
 	}
-	glog.V(4).Infof("ListDirectoryPrefixedEntries %s from %s prefix %s limit %d", dirPath, startFileName, prefix, limit)
+	// glog.V(4).Infof("ListDirectoryPrefixedEntries %s from %s prefix %s limit %d", dirPath, startFileName, prefix, limit)
 	adjustedEntryFunc := func(entry *Entry) bool {
 		fsw.maybeReadHardLink(ctx, entry)
 		filer_pb.AfterEntryDeserialization(entry.Chunks)
@@ -285,8 +298,10 @@ func (fsw *FilerStoreWrapper) prefixFilterEntries(ctx context.Context, dirPath u

 	count := int64(0)
 	for count < limit && len(notPrefixed) > 0 {
+		var isLastItemHasPrefix bool
 		for _, entry := range notPrefixed {
 			if strings.HasPrefix(entry.Name(), prefix) {
+				isLastItemHasPrefix = true
 				count++
 				if !eachEntryFunc(entry) {
 					return
@@ -294,9 +309,11 @@ func (fsw *FilerStoreWrapper) prefixFilterEntries(ctx context.Context, dirPath u
 				if count >= limit {
 					break
 				}
+			} else {
+				isLastItemHasPrefix = false
 			}
 		}
-		if count < limit {
+		if count < limit && isLastItemHasPrefix && len(notPrefixed) == int(limit) {
 			notPrefixed = notPrefixed[:0]
 			lastFileName, err = actualStore.ListDirectoryEntries(ctx, dirPath, lastFileName, false, limit, func(entry *Entry) bool {
 				notPrefixed = append(notPrefixed, entry)
@@ -305,6 +322,8 @@ func (fsw *FilerStoreWrapper) prefixFilterEntries(ctx context.Context, dirPath u
 			if err != nil {
 				return
 			}
+		} else {
+			break
 		}
 	}
 	return
@@ -13,8 +13,7 @@ import (

 func TestCreateAndFind(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &LevelDBStore{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -67,8 +66,7 @@ func TestCreateAndFind(t *testing.T) {

 func TestEmptyRoot(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test2")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &LevelDBStore{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -90,8 +88,7 @@ func TestEmptyRoot(t *testing.T) {

 func BenchmarkInsertEntry(b *testing.B) {
 	testFiler := filer.NewFiler(nil, nil, "", "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_bench")
-	defer os.RemoveAll(dir)
+	dir := b.TempDir()
 	store := &LevelDBStore{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -2,7 +2,6 @@ package leveldb

 import (
 	"context"
-	"os"
 	"testing"

 	"github.com/chrislusf/seaweedfs/weed/filer"
@@ -11,8 +10,7 @@ import (

 func TestCreateAndFind(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &LevelDB2Store{}
 	store.initialize(dir, 2)
 	testFiler.SetStore(store)
@@ -65,8 +63,7 @@ func TestCreateAndFind(t *testing.T) {

 func TestEmptyRoot(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test2")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &LevelDB2Store{}
 	store.initialize(dir, 2)
 	testFiler.SetStore(store)
@@ -72,8 +72,8 @@ func (store *LevelDB3Store) loadDB(name string) (*leveldb.DB, error) {
 	}
 	if name != DEFAULT {
 		opts = &opt.Options{
-			BlockCacheCapacity: 4 * 1024 * 1024, // default value is 8MiB
-			WriteBuffer:        2 * 1024 * 1024, // default value is 4MiB
+			BlockCacheCapacity: 16 * 1024 * 1024, // default value is 8MiB
+			WriteBuffer:        8 * 1024 * 1024,  // default value is 4MiB
 			Filter:             bloom,
 		}
 	}
@@ -2,7 +2,6 @@ package leveldb

 import (
 	"context"
-	"os"
 	"testing"

 	"github.com/chrislusf/seaweedfs/weed/filer"
@@ -11,8 +10,7 @@ import (

 func TestCreateAndFind(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &LevelDB3Store{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -65,8 +63,7 @@ func TestCreateAndFind(t *testing.T) {

 func TestEmptyRoot(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test2")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &LevelDB3Store{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -165,13 +165,14 @@ func (ma *MetaAggregator) subscribeToOneFiler(f *Filer, self pb.ServerAddress, p

 	for {
 		glog.V(4).Infof("subscribing remote %s meta change: %v", peer, time.Unix(0, lastTsNs))
-		err := pb.WithFilerClient(false, peer, ma.grpcDialOption, func(client filer_pb.SeaweedFilerClient) error {
+		err := pb.WithFilerClient(true, peer, ma.grpcDialOption, func(client filer_pb.SeaweedFilerClient) error {
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
 			stream, err := client.SubscribeLocalMetadata(ctx, &filer_pb.SubscribeMetadataRequest{
 				ClientName: "filer:" + string(self),
 				PathPrefix: "/",
 				SinceNs:    lastTsNs,
+				ClientId:   int32(ma.filer.UniqueFileId),
 			})
 			if err != nil {
 				return fmt.Errorf("subscribe: %v", err)
@@ -159,7 +159,7 @@ func (store *MongodbStore) DeleteEntry(ctx context.Context, fullpath util.FullPa
 	dir, name := fullpath.DirAndName()

 	where := bson.M{"directory": dir, "name": name}
-	_, err := store.connect.Database(store.database).Collection(store.collectionName).DeleteOne(ctx, where)
+	_, err := store.connect.Database(store.database).Collection(store.collectionName).DeleteMany(ctx, where)
 	if err != nil {
 		return fmt.Errorf("delete %s : %v", fullpath, err)
 	}
@@ -199,9 +199,9 @@ func (store *MongodbStore) ListDirectoryEntries(ctx context.Context, dirPath uti

 	for cur.Next(ctx) {
 		var data Model
-		err := cur.Decode(&data)
-		if err != nil && err != mongo.ErrNoDocuments {
-			return lastFileName, err
+		err = cur.Decode(&data)
+		if err != nil {
+			break
 		}

 		entry := &filer.Entry{
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
 	"github.com/chrislusf/seaweedfs/weed/wdclient"
-	"math"
 	"time"
 )

@@ -23,7 +22,7 @@ func ReadEntry(masterClient *wdclient.MasterClient, filerClient filer_pb.Seaweed
 		return err
 	}

-	return StreamContent(masterClient, byteBuffer, respLookupEntry.Entry.Chunks, 0, math.MaxInt64)
+	return StreamContent(masterClient, byteBuffer, respLookupEntry.Entry.Chunks, 0, int64(FileSize(respLookupEntry.Entry)))

 }

@@ -12,21 +12,16 @@ import (
 	"github.com/chrislusf/seaweedfs/weed/util"
 	"github.com/chrislusf/seaweedfs/weed/util/chunk_cache"
 	"github.com/chrislusf/seaweedfs/weed/wdclient"
-	"github.com/golang/groupcache/singleflight"
 )

 type ChunkReadAt struct {
-	masterClient *wdclient.MasterClient
-	chunkViews   []*ChunkView
-	lookupFileId wdclient.LookupFileIdFunctionType
-	readerLock   sync.Mutex
-	fileSize     int64
-
-	fetchGroup      singleflight.Group
-	chunkCache      chunk_cache.ChunkCache
-	lastChunkFileId string
-	lastChunkData   []byte
-	readerPattern   *ReaderPattern
+	masterClient  *wdclient.MasterClient
+	chunkViews    []*ChunkView
+	readerLock    sync.Mutex
+	fileSize      int64
+	readerCache   *ReaderCache
+	readerPattern *ReaderPattern
+	lastChunkFid  string
 }

 var _ = io.ReaderAt(&ChunkReadAt{})
@@ -90,16 +85,14 @@ func NewChunkReaderAtFromClient(lookupFn wdclient.LookupFileIdFunctionType, chun

 	return &ChunkReadAt{
 		chunkViews:    chunkViews,
-		lookupFileId:  lookupFn,
-		chunkCache:    chunkCache,
 		fileSize:      fileSize,
+		readerCache:   newReaderCache(32, chunkCache, lookupFn),
 		readerPattern: NewReaderPattern(),
 	}
 }

 func (c *ChunkReadAt) Close() error {
-	c.lastChunkData = nil
-	c.lastChunkFileId = ""
+	c.readerCache.destroy()
 	return nil
 }

@@ -117,15 +110,13 @@ func (c *ChunkReadAt) ReadAt(p []byte, offset int64) (n int, err error) {
 func (c *ChunkReadAt) doReadAt(p []byte, offset int64) (n int, err error) {

 	startOffset, remaining := offset, int64(len(p))
-	var nextChunk *ChunkView
+	var nextChunks []*ChunkView
 	for i, chunk := range c.chunkViews {
 		if remaining <= 0 {
 			break
 		}
 		if i+1 < len(c.chunkViews) {
-			nextChunk = c.chunkViews[i+1]
-		} else {
-			nextChunk = nil
+			nextChunks = c.chunkViews[i+1:]
 		}
 		if startOffset < chunk.LogicOffset {
 			gap := int(chunk.LogicOffset - startOffset)
@@ -142,16 +133,13 @@ func (c *ChunkReadAt) doReadAt(p []byte, offset int64) (n int, err error) {
 			continue
 		}
 		// glog.V(4).Infof("read [%d,%d), %d/%d chunk %s [%d,%d)", chunkStart, chunkStop, i, len(c.chunkViews), chunk.FileId, chunk.LogicOffset-chunk.Offset, chunk.LogicOffset-chunk.Offset+int64(chunk.Size))
-		var buffer []byte
 		bufferOffset := chunkStart - chunk.LogicOffset + chunk.Offset
-		bufferLength := chunkStop - chunkStart
-		buffer, err = c.readChunkSlice(chunk, nextChunk, uint64(bufferOffset), uint64(bufferLength))
+		copied, err := c.readChunkSliceAt(p[startOffset-offset:chunkStop-chunkStart+startOffset-offset], chunk, nextChunks, uint64(bufferOffset))
 		if err != nil {
 			glog.Errorf("fetching chunk %+v: %v\n", chunk, err)
-			return
+			return copied, err
 		}

-		copied := copy(p[startOffset-offset:chunkStop-chunkStart+startOffset-offset], buffer)
 		n += copied
 		startOffset, remaining = startOffset+int64(copied), remaining-int64(copied)
 	}
@@ -173,104 +161,25 @@ func (c *ChunkReadAt) doReadAt(p []byte, offset int64) (n int, err error) {

 }

-func (c *ChunkReadAt) readChunkSlice(chunkView *ChunkView, nextChunkViews *ChunkView, offset, length uint64) ([]byte, error) {
+func (c *ChunkReadAt) readChunkSliceAt(buffer []byte, chunkView *ChunkView, nextChunkViews []*ChunkView, offset uint64) (n int, err error) {

-	var chunkSlice []byte
-	if chunkView.LogicOffset == 0 {
-		chunkSlice = c.chunkCache.GetChunkSlice(chunkView.FileId, offset, length)
-	}
-	if len(chunkSlice) > 0 {
-		return chunkSlice, nil
-	}
-	if c.lookupFileId == nil {
-		return nil, nil
-	}
 	if c.readerPattern.IsRandomMode() {
-		return c.doFetchRangeChunkData(chunkView, offset, length)
-	}
-	chunkData, err := c.readFromWholeChunkData(chunkView, nextChunkViews)
-	if err != nil {
-		return nil, err
-	}
-	wanted := min(int64(length), int64(len(chunkData))-int64(offset))
-	return chunkData[offset : int64(offset)+wanted], nil
-}
-
-func (c *ChunkReadAt) readFromWholeChunkData(chunkView *ChunkView, nextChunkViews ...*ChunkView) (chunkData []byte, err error) {
-
-	if c.lastChunkFileId == chunkView.FileId {
-		return c.lastChunkData, nil
+		return c.readerCache.ReadChunkAt(buffer, chunkView.FileId, chunkView.CipherKey, chunkView.IsGzipped, int64(offset), int(chunkView.ChunkSize), chunkView.LogicOffset == 0)
 	}

-	v, doErr := c.readOneWholeChunk(chunkView)
-
-	if doErr != nil {
-		return nil, doErr
-	}
-
-	chunkData = v.([]byte)
-
-	c.lastChunkData = chunkData
-	c.lastChunkFileId = chunkView.FileId
-
-	for _, nextChunkView := range nextChunkViews {
-		if c.chunkCache != nil && nextChunkView != nil {
-			go c.readOneWholeChunk(nextChunkView)
+	n, err = c.readerCache.ReadChunkAt(buffer, chunkView.FileId, chunkView.CipherKey, chunkView.IsGzipped, int64(offset), int(chunkView.ChunkSize), chunkView.LogicOffset == 0)
+	if c.lastChunkFid != chunkView.FileId {
+		if chunkView.Offset == 0 { // start of a new chunk
+			if c.lastChunkFid != "" {
+				c.readerCache.UnCache(c.lastChunkFid)
+				c.readerCache.MaybeCache(nextChunkViews)
+			} else {
+				if len(nextChunkViews) >= 1 {
+					c.readerCache.MaybeCache(nextChunkViews[:1]) // just read the next chunk if at the very beginning
+				}
+			}
 		}
 	}
-
+	c.lastChunkFid = chunkView.FileId
 	return
 }
-
-func (c *ChunkReadAt) readOneWholeChunk(chunkView *ChunkView) (interface{}, error) {
-
-	var err error
-
-	return c.fetchGroup.Do(chunkView.FileId, func() (interface{}, error) {
-
-		glog.V(4).Infof("readFromWholeChunkData %s offset %d [%d,%d) size at least %d", chunkView.FileId, chunkView.Offset, chunkView.LogicOffset, chunkView.LogicOffset+int64(chunkView.Size), chunkView.ChunkSize)
-
-		var data []byte
-		if chunkView.LogicOffset == 0 {
-			data = c.chunkCache.GetChunk(chunkView.FileId, chunkView.ChunkSize)
-		}
-		if data != nil {
-			glog.V(4).Infof("cache hit %s [%d,%d)", chunkView.FileId, chunkView.LogicOffset-chunkView.Offset, chunkView.LogicOffset-chunkView.Offset+int64(len(data)))
-		} else {
-			var err error
-			data, err = c.doFetchFullChunkData(chunkView)
-			if err != nil {
-				return data, err
-			}
-			if chunkView.LogicOffset == 0 {
-				// only cache the first chunk
-				c.chunkCache.SetChunk(chunkView.FileId, data)
-			}
-		}
-		return data, err
-	})
-}
-
-func (c *ChunkReadAt) doFetchFullChunkData(chunkView *ChunkView) ([]byte, error) {
-
-	glog.V(4).Infof("+ doFetchFullChunkData %s", chunkView.FileId)
-
-	data, err := fetchChunk(c.lookupFileId, chunkView.FileId, chunkView.CipherKey, chunkView.IsGzipped)
-
-	glog.V(4).Infof("- doFetchFullChunkData %s", chunkView.FileId)
-
-	return data, err
-
-}
-
-func (c *ChunkReadAt) doFetchRangeChunkData(chunkView *ChunkView, offset, length uint64) ([]byte, error) {
-
-	glog.V(4).Infof("+ doFetchFullChunkData %s", chunkView.FileId)
-
-	data, err := fetchChunkRange(c.lookupFileId, chunkView.FileId, chunkView.CipherKey, chunkView.IsGzipped, int64(offset), int(length))
-
-	glog.V(4).Infof("- doFetchFullChunkData %s", chunkView.FileId)
-
-	return data, err
-
-}
@@ -21,8 +21,12 @@ func (m *mockChunkCache) GetChunk(fileId string, minSize uint64) (data []byte) {
 	return data
 }

-func (m *mockChunkCache) GetChunkSlice(fileId string, offset, length uint64) []byte {
-	return m.GetChunk(fileId, length)
+func (m *mockChunkCache) ReadChunkAt(data []byte, fileId string, offset uint64) (n int, err error) {
+	x, _ := strconv.Atoi(fileId)
+	for i := 0; i < len(data); i++ {
+		data[i] = byte(x)
+	}
+	return len(data), nil
 }

 func (m *mockChunkCache) SetChunk(fileId string, data []byte) {
@@ -65,10 +69,9 @@ func TestReaderAt(t *testing.T) {

 	readerAt := &ChunkReadAt{
 		chunkViews:    ViewFromVisibleIntervals(visibles, 0, math.MaxInt64),
-		lookupFileId:  nil,
 		readerLock:    sync.Mutex{},
 		fileSize:      10,
-		chunkCache:    &mockChunkCache{},
+		readerCache:   newReaderCache(3, &mockChunkCache{}, nil),
 		readerPattern: NewReaderPattern(),
 	}

@@ -116,10 +119,9 @@ func TestReaderAt0(t *testing.T) {

 	readerAt := &ChunkReadAt{
 		chunkViews:    ViewFromVisibleIntervals(visibles, 0, math.MaxInt64),
-		lookupFileId:  nil,
 		readerLock:    sync.Mutex{},
 		fileSize:      10,
-		chunkCache:    &mockChunkCache{},
+		readerCache:   newReaderCache(3, &mockChunkCache{}, nil),
 		readerPattern: NewReaderPattern(),
 	}

@@ -145,10 +147,9 @@ func TestReaderAt1(t *testing.T) {

 	readerAt := &ChunkReadAt{
 		chunkViews:    ViewFromVisibleIntervals(visibles, 0, math.MaxInt64),
-		lookupFileId:  nil,
 		readerLock:    sync.Mutex{},
 		fileSize:      20,
-		chunkCache:    &mockChunkCache{},
+		readerCache:   newReaderCache(3, &mockChunkCache{}, nil),
 		readerPattern: NewReaderPattern(),
 	}

@@ -0,0 +1,188 @@
+package filer
+
+import (
+	"fmt"
+	"github.com/chrislusf/seaweedfs/weed/util/chunk_cache"
+	"github.com/chrislusf/seaweedfs/weed/util/mem"
+	"github.com/chrislusf/seaweedfs/weed/wdclient"
+	"sync"
+	"time"
+)
+
+type ReaderCache struct {
+	chunkCache     chunk_cache.ChunkCache
+	lookupFileIdFn wdclient.LookupFileIdFunctionType
+	sync.Mutex
+	downloaders map[string]*SingleChunkCacher
+	limit       int
+}
+
+type SingleChunkCacher struct {
+	sync.RWMutex
+	parent        *ReaderCache
+	chunkFileId   string
+	data          []byte
+	err           error
+	cipherKey     []byte
+	isGzipped     bool
+	chunkSize     int
+	shouldCache   bool
+	wg            sync.WaitGroup
+	completedTime time.Time
+}
+
+func newReaderCache(limit int, chunkCache chunk_cache.ChunkCache, lookupFileIdFn wdclient.LookupFileIdFunctionType) *ReaderCache {
+	return &ReaderCache{
+		limit:          limit,
+		chunkCache:     chunkCache,
+		lookupFileIdFn: lookupFileIdFn,
+		downloaders:    make(map[string]*SingleChunkCacher),
+	}
+}
+
+func (rc *ReaderCache) MaybeCache(chunkViews []*ChunkView) {
+	if rc.lookupFileIdFn == nil {
+		return
+	}
+
+	rc.Lock()
+	defer rc.Unlock()
+
+	for _, chunkView := range chunkViews {
+		if _, found := rc.downloaders[chunkView.FileId]; found {
+			continue
+		}
+
+		if len(rc.downloaders) >= rc.limit {
+			// if still no slots, return
+			return
+		}
+
+		// glog.V(4).Infof("prefetch %s offset %d", chunkView.FileId, chunkView.LogicOffset)
+		// cache this chunk if not yet
+		cacher := newSingleChunkCacher(rc, chunkView.FileId, chunkView.CipherKey, chunkView.IsGzipped, int(chunkView.ChunkSize), false)
+		cacher.wg.Add(1)
+		go cacher.startCaching()
+		cacher.wg.Wait()
+		rc.downloaders[chunkView.FileId] = cacher
+
+	}
+
+	return
+}
+
+func (rc *ReaderCache) ReadChunkAt(buffer []byte, fileId string, cipherKey []byte, isGzipped bool, offset int64, chunkSize int, shouldCache bool) (int, error) {
+	rc.Lock()
+	defer rc.Unlock()
+	if cacher, found := rc.downloaders[fileId]; found {
+		return cacher.readChunkAt(buffer, offset)
+	}
+	if shouldCache || rc.lookupFileIdFn == nil {
+		n, err := rc.chunkCache.ReadChunkAt(buffer, fileId, uint64(offset))
+		if n > 0 {
+			return n, err
+		}
+	}
+
+	if len(rc.downloaders) >= rc.limit {
+		oldestFid, oldestTime := "", time.Now()
+		for fid, downloader := range rc.downloaders {
+			if !downloader.completedTime.IsZero() {
+				if downloader.completedTime.Before(oldestTime) {
+					oldestFid, oldestTime = fid, downloader.completedTime
+				}
+			}
+		}
+		if oldestFid != "" {
+			oldDownloader := rc.downloaders[oldestFid]
+			delete(rc.downloaders, oldestFid)
+			oldDownloader.destroy()
+		}
+	}
+
+	// glog.V(4).Infof("cache1 %s", fileId)
+
+	cacher := newSingleChunkCacher(rc, fileId, cipherKey, isGzipped, chunkSize, shouldCache)
+	cacher.wg.Add(1)
+	go cacher.startCaching()
+	cacher.wg.Wait()
+	rc.downloaders[fileId] = cacher
+
+	return cacher.readChunkAt(buffer, offset)
+}
+
+func (rc *ReaderCache) UnCache(fileId string) {
+	rc.Lock()
+	defer rc.Unlock()
+	// glog.V(4).Infof("uncache %s", fileId)
+	if downloader, found := rc.downloaders[fileId]; found {
+		downloader.destroy()
+		delete(rc.downloaders, fileId)
+	}
+}
+
+func (rc *ReaderCache) destroy() {
+	rc.Lock()
+	defer rc.Unlock()
+
+	for _, downloader := range rc.downloaders {
+		downloader.destroy()
+	}
+
+}
+
+func newSingleChunkCacher(parent *ReaderCache, fileId string, cipherKey []byte, isGzipped bool, chunkSize int, shouldCache bool) *SingleChunkCacher {
+	t := &SingleChunkCacher{
+		parent:      parent,
+		chunkFileId: fileId,
+		cipherKey:   cipherKey,
+		isGzipped:   isGzipped,
+		chunkSize:   chunkSize,
+		shouldCache: shouldCache,
+	}
+	return t
+}
+
+func (s *SingleChunkCacher) startCaching() {
+	s.Lock()
+	defer s.Unlock()
+
+	s.wg.Done() // means this has been started
+
+	urlStrings, err := s.parent.lookupFileIdFn(s.chunkFileId)
+	if err != nil {
+		s.err = fmt.Errorf("operation LookupFileId %s failed, err: %v", s.chunkFileId, err)
+		return
+	}
+
+	s.data = mem.Allocate(s.chunkSize)
+
+	_, s.err = retriedFetchChunkData(s.data, urlStrings, s.cipherKey, s.isGzipped, true, 0)
+	if s.err != nil {
+		mem.Free(s.data)
+		s.data = nil
+		return
+	}
+
+	s.completedTime = time.Now()
+	if s.shouldCache {
+		s.parent.chunkCache.SetChunk(s.chunkFileId, s.data)
+	}
+
+	return
+}
+
+func (s *SingleChunkCacher) destroy() {
+	if s.data != nil {
+		mem.Free(s.data)
+		s.data = nil
+	}
+}
+
+func (s *SingleChunkCacher) readChunkAt(buf []byte, offset int64) (int, error) {
+	s.RLock()
+	defer s.RUnlock()
+
+	return copy(buf, s.data[offset:]), s.err
+
+}
@@ -0,0 +1,44 @@
+package redis_lua
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/chrislusf/seaweedfs/weed/util"
+	"github.com/go-redis/redis/v8"
+)
+
+func init() {
+	filer.Stores = append(filer.Stores, &RedisLuaClusterStore{})
+}
+
+type RedisLuaClusterStore struct {
+	UniversalRedisLuaStore
+}
+
+func (store *RedisLuaClusterStore) GetName() string {
+	return "redis_lua_cluster"
+}
+
+func (store *RedisLuaClusterStore) Initialize(configuration util.Configuration, prefix string) (err error) {
+
+	configuration.SetDefault(prefix+"useReadOnly", false)
+	configuration.SetDefault(prefix+"routeByLatency", false)
+
+	return store.initialize(
+		configuration.GetStringSlice(prefix+"addresses"),
+		configuration.GetString(prefix+"password"),
+		configuration.GetBool(prefix+"useReadOnly"),
+		configuration.GetBool(prefix+"routeByLatency"),
+		configuration.GetStringSlice(prefix+"superLargeDirectories"),
+	)
+}
+
+func (store *RedisLuaClusterStore) initialize(addresses []string, password string, readOnly, routeByLatency bool, superLargeDirectories []string) (err error) {
+	store.Client = redis.NewClusterClient(&redis.ClusterOptions{
+		Addrs:          addresses,
+		Password:       password,
+		ReadOnly:       readOnly,
+		RouteByLatency: routeByLatency,
+	})
+	store.loadSuperLargeDirectories(superLargeDirectories)
+	return
+}
@@ -0,0 +1,45 @@
+package redis_lua
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/chrislusf/seaweedfs/weed/util"
+	"github.com/go-redis/redis/v8"
+	"time"
+)
+
+func init() {
+	filer.Stores = append(filer.Stores, &RedisLuaSentinelStore{})
+}
+
+type RedisLuaSentinelStore struct {
+	UniversalRedisLuaStore
+}
+
+func (store *RedisLuaSentinelStore) GetName() string {
+	return "redis_lua_sentinel"
+}
+
+func (store *RedisLuaSentinelStore) Initialize(configuration util.Configuration, prefix string) (err error) {
+	return store.initialize(
+		configuration.GetStringSlice(prefix+"addresses"),
+		configuration.GetString(prefix+"masterName"),
+		configuration.GetString(prefix+"username"),
+		configuration.GetString(prefix+"password"),
+		configuration.GetInt(prefix+"database"),
+	)
+}
+
+func (store *RedisLuaSentinelStore) initialize(addresses []string, masterName string, username string, password string, database int) (err error) {
+	store.Client = redis.NewFailoverClient(&redis.FailoverOptions{
+		MasterName:      masterName,
+		SentinelAddrs:   addresses,
+		Username:        username,
+		Password:        password,
+		DB:              database,
+		MinRetryBackoff: time.Millisecond * 100,
+		MaxRetryBackoff: time.Minute * 1,
+		ReadTimeout:     time.Second * 30,
+		WriteTimeout:    time.Second * 5,
+	})
+	return
+}
@@ -0,0 +1,38 @@
+package redis_lua
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/chrislusf/seaweedfs/weed/util"
+	"github.com/go-redis/redis/v8"
+)
+
+func init() {
+	filer.Stores = append(filer.Stores, &RedisLuaStore{})
+}
+
+type RedisLuaStore struct {
+	UniversalRedisLuaStore
+}
+
+func (store *RedisLuaStore) GetName() string {
+	return "redis_lua"
+}
+
+func (store *RedisLuaStore) Initialize(configuration util.Configuration, prefix string) (err error) {
+	return store.initialize(
+		configuration.GetString(prefix+"address"),
+		configuration.GetString(prefix+"password"),
+		configuration.GetInt(prefix+"database"),
+		configuration.GetStringSlice(prefix+"superLargeDirectories"),
+	)
+}
+
+func (store *RedisLuaStore) initialize(hostPort string, password string, database int, superLargeDirectories []string) (err error) {
+	store.Client = redis.NewClient(&redis.Options{
+		Addr:     hostPort,
+		Password: password,
+		DB:       database,
+	})
+	store.loadSuperLargeDirectories(superLargeDirectories)
+	return
+}
@@ -0,0 +1,19 @@
+-- KEYS[1]: full path of entry
+local fullpath = KEYS[1]
+-- KEYS[2]: full path of entry
+local fullpath_list_key = KEYS[2]
+-- KEYS[3]: dir of the entry
+local dir_list_key = KEYS[3]
+
+-- ARGV[1]: isSuperLargeDirectory
+local isSuperLargeDirectory = ARGV[1] == "1"
+-- ARGV[2]: name of the entry
+local name = ARGV[2]
+
+redis.call("DEL", fullpath, fullpath_list_key)
+
+if not isSuperLargeDirectory and name ~= "" then
+    redis.call("ZREM", dir_list_key, name)
+end
+
+return 0
@@ -0,0 +1,15 @@
+-- KEYS[1]: full path of entry
+local fullpath = KEYS[1]
+
+if fullpath ~= "" and string.sub(fullpath, -1) == "/" then
+    fullpath = string.sub(fullpath, 0, -2)
+end
+
+local files = redis.call("ZRANGE", fullpath .. "\0", "0", "-1")
+
+for _, name in ipairs(files) do
+    local file_path = fullpath .. "/" .. name
+    redis.call("DEL", file_path, file_path .. "\0")
+end
+
+return 0
@@ -0,0 +1,24 @@
+package stored_procedure
+
+import (
+	_ "embed"
+	"github.com/go-redis/redis/v8"
+)
+
+func init() {
+	InsertEntryScript = redis.NewScript(insertEntry)
+	DeleteEntryScript = redis.NewScript(deleteEntry)
+	DeleteFolderChildrenScript = redis.NewScript(deleteFolderChildren)
+}
+
+//go:embed insert_entry.lua
+var insertEntry string
+var InsertEntryScript *redis.Script
+
+//go:embed delete_entry.lua
+var deleteEntry string
+var DeleteEntryScript *redis.Script
+
+//go:embed delete_folder_children.lua
+var deleteFolderChildren string
+var DeleteFolderChildrenScript *redis.Script
@@ -0,0 +1,27 @@
+-- KEYS[1]: full path of entry
+local full_path = KEYS[1]
+-- KEYS[2]: dir of the entry
+local dir_list_key = KEYS[2]
+
+-- ARGV[1]: content of the entry
+local entry = ARGV[1]
+-- ARGV[2]: TTL of the entry
+local ttlSec = tonumber(ARGV[2])
+-- ARGV[3]: isSuperLargeDirectory
+local isSuperLargeDirectory = ARGV[3] == "1"
+-- ARGV[4]: zscore of the entry in zset
+local zscore = tonumber(ARGV[4])
+-- ARGV[5]: name of the entry
+local name = ARGV[5]
+
+if ttlSec > 0 then
+    redis.call("SET", full_path, entry, "EX", ttlSec)
+else
+    redis.call("SET", full_path, entry)
+end
+
+if not isSuperLargeDirectory and name ~= "" then
+    redis.call("ZADD", dir_list_key, "NX", zscore, name)
+end
+
+return 0
@@ -0,0 +1,191 @@
+package redis_lua
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/chrislusf/seaweedfs/weed/filer/redis_lua/stored_procedure"
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
+	"github.com/chrislusf/seaweedfs/weed/util"
+)
+
+const (
+	DIR_LIST_MARKER = "\x00"
+)
+
+type UniversalRedisLuaStore struct {
+	Client                  redis.UniversalClient
+	superLargeDirectoryHash map[string]bool
+}
+
+func (store *UniversalRedisLuaStore) isSuperLargeDirectory(dir string) (isSuperLargeDirectory bool) {
+	_, isSuperLargeDirectory = store.superLargeDirectoryHash[dir]
+	return
+}
+
+func (store *UniversalRedisLuaStore) loadSuperLargeDirectories(superLargeDirectories []string) {
+	// set directory hash
+	store.superLargeDirectoryHash = make(map[string]bool)
+	for _, dir := range superLargeDirectories {
+		store.superLargeDirectoryHash[dir] = true
+	}
+}
+
+func (store *UniversalRedisLuaStore) BeginTransaction(ctx context.Context) (context.Context, error) {
+	return ctx, nil
+}
+func (store *UniversalRedisLuaStore) CommitTransaction(ctx context.Context) error {
+	return nil
+}
+func (store *UniversalRedisLuaStore) RollbackTransaction(ctx context.Context) error {
+	return nil
+}
+
+func (store *UniversalRedisLuaStore) InsertEntry(ctx context.Context, entry *filer.Entry) (err error) {
+
+	value, err := entry.EncodeAttributesAndChunks()
+	if err != nil {
+		return fmt.Errorf("encoding %s %+v: %v", entry.FullPath, entry.Attr, err)
+	}
+
+	if len(entry.Chunks) > 50 {
+		value = util.MaybeGzipData(value)
+	}
+
+	dir, name := entry.FullPath.DirAndName()
+
+	err = stored_procedure.InsertEntryScript.Run(ctx, store.Client,
+		[]string{string(entry.FullPath), genDirectoryListKey(dir)},
+		value, entry.TtlSec,
+		store.isSuperLargeDirectory(dir), 0, name).Err()
+
+	if err != nil {
+		return fmt.Errorf("persisting %s : %v", entry.FullPath, err)
+	}
+
+	return nil
+}
+
+func (store *UniversalRedisLuaStore) UpdateEntry(ctx context.Context, entry *filer.Entry) (err error) {
+
+	return store.InsertEntry(ctx, entry)
+}
+
+func (store *UniversalRedisLuaStore) FindEntry(ctx context.Context, fullpath util.FullPath) (entry *filer.Entry, err error) {
+
+	data, err := store.Client.Get(ctx, string(fullpath)).Result()
+	if err == redis.Nil {
+		return nil, filer_pb.ErrNotFound
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("get %s : %v", fullpath, err)
+	}
+
+	entry = &filer.Entry{
+		FullPath: fullpath,
+	}
+	err = entry.DecodeAttributesAndChunks(util.MaybeDecompressData([]byte(data)))
+	if err != nil {
+		return entry, fmt.Errorf("decode %s : %v", entry.FullPath, err)
+	}
+
+	return entry, nil
+}
+
+func (store *UniversalRedisLuaStore) DeleteEntry(ctx context.Context, fullpath util.FullPath) (err error) {
+
+	dir, name := fullpath.DirAndName()
+
+	err = stored_procedure.DeleteEntryScript.Run(ctx, store.Client,
+		[]string{string(fullpath), genDirectoryListKey(string(fullpath)), genDirectoryListKey(dir)},
+		store.isSuperLargeDirectory(dir), name).Err()
+
+	if err != nil {
+		return fmt.Errorf("DeleteEntry %s : %v", fullpath, err)
+	}
+
+	return nil
+}
+
+func (store *UniversalRedisLuaStore) DeleteFolderChildren(ctx context.Context, fullpath util.FullPath) (err error) {
+
+	if store.isSuperLargeDirectory(string(fullpath)) {
+		return nil
+	}
+
+	err = stored_procedure.DeleteFolderChildrenScript.Run(ctx, store.Client,
+		[]string{string(fullpath)}).Err()
+
+	if err != nil {
+		return fmt.Errorf("DeleteFolderChildren %s : %v", fullpath, err)
+	}
+
+	return nil
+}
+
+func (store *UniversalRedisLuaStore) ListDirectoryPrefixedEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, prefix string, eachEntryFunc filer.ListEachEntryFunc) (lastFileName string, err error) {
+	return lastFileName, filer.ErrUnsupportedListDirectoryPrefixed
+}
+
+func (store *UniversalRedisLuaStore) ListDirectoryEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, eachEntryFunc filer.ListEachEntryFunc) (lastFileName string, err error) {
+
+	dirListKey := genDirectoryListKey(string(dirPath))
+
+	min := "-"
+	if startFileName != "" {
+		if includeStartFile {
+			min = "[" + startFileName
+		} else {
+			min = "(" + startFileName
+		}
+	}
+
+	members, err := store.Client.ZRangeByLex(ctx, dirListKey, &redis.ZRangeBy{
+		Min:    min,
+		Max:    "+",
+		Offset: 0,
+		Count:  limit,
+	}).Result()
+	if err != nil {
+		return lastFileName, fmt.Errorf("list %s : %v", dirPath, err)
+	}
+
+	// fetch entry meta
+	for _, fileName := range members {
+		path := util.NewFullPath(string(dirPath), fileName)
+		entry, err := store.FindEntry(ctx, path)
+		lastFileName = fileName
+		if err != nil {
+			glog.V(0).Infof("list %s : %v", path, err)
+			if err == filer_pb.ErrNotFound {
+				continue
+			}
+		} else {
+			if entry.TtlSec > 0 {
+				if entry.Attr.Crtime.Add(time.Duration(entry.TtlSec) * time.Second).Before(time.Now()) {
+					store.DeleteEntry(ctx, path)
+					continue
+				}
+			}
+			if !eachEntryFunc(entry) {
+				break
+			}
+		}
+	}
+
+	return lastFileName, err
+}
+
+func genDirectoryListKey(dir string) (dirList string) {
+	return dir + DIR_LIST_MARKER
+}
+
+func (store *UniversalRedisLuaStore) Shutdown() {
+	store.Client.Close()
+}
@@ -0,0 +1,42 @@
+package redis_lua
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/go-redis/redis/v8"
+)
+
+func (store *UniversalRedisLuaStore) KvPut(ctx context.Context, key []byte, value []byte) (err error) {
+
+	_, err = store.Client.Set(ctx, string(key), value, 0).Result()
+
+	if err != nil {
+		return fmt.Errorf("kv put: %v", err)
+	}
+
+	return nil
+}
+
+func (store *UniversalRedisLuaStore) KvGet(ctx context.Context, key []byte) (value []byte, err error) {
+
+	data, err := store.Client.Get(ctx, string(key)).Result()
+
+	if err == redis.Nil {
+		return nil, filer.ErrKvNotFound
+	}
+
+	return []byte(data), err
+}
+
+func (store *UniversalRedisLuaStore) KvDelete(ctx context.Context, key []byte) (err error) {
+
+	_, err = store.Client.Del(ctx, string(key)).Result()
+
+	if err != nil {
+		return fmt.Errorf("kv delete: %v", err)
+	}
+
+	return nil
+}
@@ -16,8 +16,7 @@ import (

 func TestCreateAndFind(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", 0, "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &RocksDBStore{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -70,8 +69,7 @@ func TestCreateAndFind(t *testing.T) {

 func TestEmptyRoot(t *testing.T) {
 	testFiler := filer.NewFiler(nil, nil, "", 0, "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_test2")
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	store := &RocksDBStore{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -93,8 +91,7 @@ func TestEmptyRoot(t *testing.T) {

 func BenchmarkInsertEntry(b *testing.B) {
 	testFiler := filer.NewFiler(nil, nil, "", 0, "", "", "", nil)
-	dir, _ := os.MkdirTemp("", "seaweedfs_filer_bench")
-	defer os.RemoveAll(dir)
+	dir := b.TempDir()
 	store := &RocksDBStore{}
 	store.initialize(dir)
 	testFiler.SetStore(store)
@@ -133,30 +133,30 @@ func writeZero(w io.Writer, size int64) (err error) {
 	return
 }

-func ReadAll(masterClient *wdclient.MasterClient, chunks []*filer_pb.FileChunk) ([]byte, error) {
-
-	buffer := bytes.Buffer{}
+func ReadAll(buffer []byte, masterClient *wdclient.MasterClient, chunks []*filer_pb.FileChunk) error {

 	lookupFileIdFn := func(fileId string) (targetUrls []string, err error) {
 		return masterClient.LookupFileId(fileId)
 	}

-	chunkViews := ViewFromChunks(lookupFileIdFn, chunks, 0, math.MaxInt64)
+	chunkViews := ViewFromChunks(lookupFileIdFn, chunks, 0, int64(len(buffer)))
+
+	idx := 0

 	for _, chunkView := range chunkViews {
 		urlStrings, err := lookupFileIdFn(chunkView.FileId)
 		if err != nil {
 			glog.V(1).Infof("operation LookupFileId %s failed, err: %v", chunkView.FileId, err)
-			return nil, err
+			return err
 		}

-		data, err := retriedFetchChunkData(urlStrings, chunkView.CipherKey, chunkView.IsGzipped, chunkView.IsFullChunk(), chunkView.Offset, int(chunkView.Size))
+		n, err := retriedFetchChunkData(buffer[idx:idx+int(chunkView.Size)], urlStrings, chunkView.CipherKey, chunkView.IsGzipped, chunkView.IsFullChunk(), chunkView.Offset)
 		if err != nil {
-			return nil, err
+			return err
 		}
-		buffer.Write(data)
+		idx += n
 	}
-	return buffer.Bytes(), nil
+	return nil
 }

 // ----------------  ChunkStreamReader ----------------------------------
@@ -1,655 +0,0 @@
-package filesys
-
-import (
-	"bytes"
-	"context"
-	"math"
-	"os"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-
-	"github.com/chrislusf/seaweedfs/weed/filer"
-	"github.com/chrislusf/seaweedfs/weed/filesys/meta_cache"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/chrislusf/seaweedfs/weed/util"
-)
-
-type Dir struct {
-	name   string
-	wfs    *WFS
-	entry  *filer_pb.Entry
-	parent *Dir
-	id     uint64
-}
-
-var _ = fs.Node(&Dir{})
-
-var _ = fs.NodeIdentifier(&Dir{})
-var _ = fs.NodeCreater(&Dir{})
-var _ = fs.NodeMknoder(&Dir{})
-var _ = fs.NodeMkdirer(&Dir{})
-var _ = fs.NodeFsyncer(&Dir{})
-var _ = fs.NodeRequestLookuper(&Dir{})
-var _ = fs.HandleReadDirAller(&Dir{})
-var _ = fs.NodeRemover(&Dir{})
-var _ = fs.NodeRenamer(&Dir{})
-var _ = fs.NodeSetattrer(&Dir{})
-var _ = fs.NodeGetxattrer(&Dir{})
-var _ = fs.NodeSetxattrer(&Dir{})
-var _ = fs.NodeRemovexattrer(&Dir{})
-var _ = fs.NodeListxattrer(&Dir{})
-var _ = fs.NodeForgetter(&Dir{})
-
-func (dir *Dir) Id() uint64 {
-	if dir.parent == nil {
-		return 1
-	}
-	return dir.id
-}
-
-func (dir *Dir) Attr(ctx context.Context, attr *fuse.Attr) error {
-
-	entry, err := dir.maybeLoadEntry()
-	if err != nil {
-		glog.V(3).Infof("dir Attr %s, err: %+v", dir.FullPath(), err)
-		return err
-	}
-
-	// https://github.com/bazil/fuse/issues/196
-	attr.Valid = time.Second
-	attr.Inode = dir.Id()
-	attr.Mode = os.FileMode(entry.Attributes.FileMode) | os.ModeDir
-	attr.Mtime = time.Unix(entry.Attributes.Mtime, 0)
-	attr.Crtime = time.Unix(entry.Attributes.Crtime, 0)
-	attr.Ctime = time.Unix(entry.Attributes.Mtime, 0)
-	attr.Atime = time.Unix(entry.Attributes.Mtime, 0)
-	attr.Gid = entry.Attributes.Gid
-	attr.Uid = entry.Attributes.Uid
-
-	if dir.FullPath() == dir.wfs.option.FilerMountRootPath {
-		attr.BlockSize = blockSize
-	}
-
-	glog.V(4).Infof("dir Attr %s, attr: %+v", dir.FullPath(), attr)
-
-	return nil
-}
-
-func (dir *Dir) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, resp *fuse.GetxattrResponse) error {
-
-	glog.V(4).Infof("dir Getxattr %s", dir.FullPath())
-
-	entry, err := dir.maybeLoadEntry()
-	if err != nil {
-		return err
-	}
-
-	return getxattr(entry, req, resp)
-}
-
-func (dir *Dir) Fsync(ctx context.Context, req *fuse.FsyncRequest) error {
-	// fsync works at OS level
-	// write the file chunks to the filerGrpcAddress
-	glog.V(3).Infof("dir %s fsync %+v", dir.FullPath(), req)
-
-	return nil
-}
-
-func (dir *Dir) newFile(name string, fileMode os.FileMode) fs.Node {
-
-	fileFullPath := util.NewFullPath(dir.FullPath(), name)
-	fileId := fileFullPath.AsInode(fileMode)
-	dir.wfs.handlesLock.Lock()
-	existingHandle, found := dir.wfs.handles[fileId]
-	dir.wfs.handlesLock.Unlock()
-
-	if found {
-		glog.V(4).Infof("newFile found opened file handle: %+v", fileFullPath)
-		return existingHandle.f
-	}
-	return &File{
-		Name: name,
-		dir:  dir,
-		wfs:  dir.wfs,
-		id:   fileId,
-	}
-}
-
-func (dir *Dir) newDirectory(fullpath util.FullPath) fs.Node {
-
-	return &Dir{name: fullpath.Name(), wfs: dir.wfs, parent: dir, id: fullpath.AsInode(os.ModeDir)}
-
-}
-
-func (dir *Dir) Create(ctx context.Context, req *fuse.CreateRequest,
-	resp *fuse.CreateResponse) (fs.Node, fs.Handle, error) {
-
-	if err := checkName(req.Name); err != nil {
-		return nil, nil, err
-	}
-
-	exclusive := req.Flags&fuse.OpenExclusive != 0
-	isDirectory := req.Mode&os.ModeDir > 0
-
-	if exclusive || isDirectory {
-		_, err := dir.doCreateEntry(req.Name, req.Mode, req.Uid, req.Gid, exclusive)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-	var node fs.Node
-	if isDirectory {
-		node = dir.newDirectory(util.NewFullPath(dir.FullPath(), req.Name))
-		return node, node, nil
-	}
-
-	node = dir.newFile(req.Name, req.Mode)
-	file := node.(*File)
-	file.entry = &filer_pb.Entry{
-		Name:        req.Name,
-		IsDirectory: req.Mode&os.ModeDir > 0,
-		Attributes: &filer_pb.FuseAttributes{
-			Mtime:       time.Now().Unix(),
-			Crtime:      time.Now().Unix(),
-			FileMode:    uint32(req.Mode &^ dir.wfs.option.Umask),
-			Uid:         req.Uid,
-			Gid:         req.Gid,
-			Collection:  dir.wfs.option.Collection,
-			Replication: dir.wfs.option.Replication,
-			TtlSec:      dir.wfs.option.TtlSec,
-		},
-	}
-	file.dirtyMetadata = true
-	fh := dir.wfs.AcquireHandle(file, req.Uid, req.Gid)
-	return file, fh, nil
-
-}
-
-func (dir *Dir) Mknod(ctx context.Context, req *fuse.MknodRequest) (fs.Node, error) {
-
-	if err := checkName(req.Name); err != nil {
-		return nil, err
-	}
-
-	glog.V(3).Infof("dir %s Mknod %+v", dir.FullPath(), req)
-
-	_, err := dir.doCreateEntry(req.Name, req.Mode, req.Uid, req.Gid, false)
-
-	if err != nil {
-		return nil, err
-	}
-	var node fs.Node
-	node = dir.newFile(req.Name, req.Mode)
-	return node, nil
-}
-
-func (dir *Dir) doCreateEntry(name string, mode os.FileMode, uid, gid uint32, exclusive bool) (*filer_pb.CreateEntryRequest, error) {
-	dirFullPath := dir.FullPath()
-	request := &filer_pb.CreateEntryRequest{
-		Directory: dirFullPath,
-		Entry: &filer_pb.Entry{
-			Name:        name,
-			IsDirectory: mode&os.ModeDir > 0,
-			Attributes: &filer_pb.FuseAttributes{
-				Mtime:       time.Now().Unix(),
-				Crtime:      time.Now().Unix(),
-				FileMode:    uint32(mode &^ dir.wfs.option.Umask),
-				Uid:         uid,
-				Gid:         gid,
-				Collection:  dir.wfs.option.Collection,
-				Replication: dir.wfs.option.Replication,
-				TtlSec:      dir.wfs.option.TtlSec,
-			},
-		},
-		OExcl:      exclusive,
-		Signatures: []int32{dir.wfs.signature},
-	}
-	glog.V(1).Infof("create %s/%s", dirFullPath, name)
-
-	err := dir.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		dir.wfs.mapPbIdFromLocalToFiler(request.Entry)
-		defer dir.wfs.mapPbIdFromFilerToLocal(request.Entry)
-
-		if err := filer_pb.CreateEntry(client, request); err != nil {
-			if strings.Contains(err.Error(), "EEXIST") {
-				return fuse.EEXIST
-			}
-			glog.V(0).Infof("create %s/%s: %v", dirFullPath, name, err)
-			return fuse.EIO
-		}
-
-		if err := dir.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)); err != nil {
-			glog.Errorf("local InsertEntry dir %s/%s: %v", dirFullPath, name, err)
-			return fuse.EIO
-		}
-
-		return nil
-	})
-	return request, err
-}
-
-func (dir *Dir) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (fs.Node, error) {
-
-	if err := checkName(req.Name); err != nil {
-		return nil, err
-	}
-
-	glog.V(4).Infof("mkdir %s: %s", dir.FullPath(), req.Name)
-
-	newEntry := &filer_pb.Entry{
-		Name:        req.Name,
-		IsDirectory: true,
-		Attributes: &filer_pb.FuseAttributes{
-			Mtime:    time.Now().Unix(),
-			Crtime:   time.Now().Unix(),
-			FileMode: uint32(req.Mode &^ dir.wfs.option.Umask),
-			Uid:      req.Uid,
-			Gid:      req.Gid,
-		},
-	}
-
-	dirFullPath := dir.FullPath()
-
-	err := dir.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		dir.wfs.mapPbIdFromLocalToFiler(newEntry)
-		defer dir.wfs.mapPbIdFromFilerToLocal(newEntry)
-
-		request := &filer_pb.CreateEntryRequest{
-			Directory:  dirFullPath,
-			Entry:      newEntry,
-			Signatures: []int32{dir.wfs.signature},
-		}
-
-		glog.V(1).Infof("mkdir: %v", request)
-		if err := filer_pb.CreateEntry(client, request); err != nil {
-			glog.V(0).Infof("mkdir %s/%s: %v", dirFullPath, req.Name, err)
-			return err
-		}
-
-		if err := dir.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)); err != nil {
-			glog.Errorf("local mkdir dir %s/%s: %v", dirFullPath, req.Name, err)
-			return fuse.EIO
-		}
-
-		return nil
-	})
-
-	if err == nil {
-		node := dir.newDirectory(util.NewFullPath(dirFullPath, req.Name))
-
-		return node, nil
-	}
-
-	glog.V(0).Infof("mkdir %s/%s: %v", dirFullPath, req.Name, err)
-
-	return nil, fuse.EIO
-}
-
-func (dir *Dir) Lookup(ctx context.Context, req *fuse.LookupRequest, resp *fuse.LookupResponse) (node fs.Node, err error) {
-
-	if err := checkName(req.Name); err != nil {
-		return nil, err
-	}
-
-	dirPath := util.FullPath(dir.FullPath())
-	// glog.V(4).Infof("dir Lookup %s: %s by %s", dirPath, req.Name, req.Header.String())
-
-	fullFilePath := dirPath.Child(req.Name)
-	visitErr := meta_cache.EnsureVisited(dir.wfs.metaCache, dir.wfs, dirPath)
-	if visitErr != nil {
-		glog.Errorf("dir Lookup %s: %v", dirPath, visitErr)
-		return nil, fuse.EIO
-	}
-	localEntry, cacheErr := dir.wfs.metaCache.FindEntry(context.Background(), fullFilePath)
-	if cacheErr == filer_pb.ErrNotFound {
-		return nil, fuse.ENOENT
-	}
-
-	if localEntry == nil {
-		// glog.V(3).Infof("dir Lookup cache miss %s", fullFilePath)
-		entry, err := filer_pb.GetEntry(dir.wfs, fullFilePath)
-		if err != nil {
-			glog.V(1).Infof("dir GetEntry %s: %v", fullFilePath, err)
-			return nil, fuse.ENOENT
-		}
-		localEntry = filer.FromPbEntry(string(dirPath), entry)
-	} else {
-		glog.V(4).Infof("dir Lookup cache hit %s", fullFilePath)
-	}
-
-	if localEntry != nil {
-		if localEntry.IsDirectory() {
-			node = dir.newDirectory(fullFilePath)
-		} else {
-			node = dir.newFile(req.Name, localEntry.Attr.Mode)
-		}
-
-		// resp.EntryValid = time.Second
-		resp.Attr.Valid = time.Second
-		resp.Attr.Size = localEntry.FileSize
-		resp.Attr.Mtime = localEntry.Attr.Mtime
-		resp.Attr.Crtime = localEntry.Attr.Crtime
-		resp.Attr.Mode = localEntry.Attr.Mode
-		resp.Attr.Gid = localEntry.Attr.Gid
-		resp.Attr.Uid = localEntry.Attr.Uid
-		if localEntry.HardLinkCounter > 0 {
-			resp.Attr.Nlink = uint32(localEntry.HardLinkCounter)
-		}
-
-		return node, nil
-	}
-
-	glog.V(4).Infof("not found dir GetEntry %s: %v", fullFilePath, err)
-	return nil, fuse.ENOENT
-}
-
-func (dir *Dir) ReadDirAll(ctx context.Context) (ret []fuse.Dirent, err error) {
-
-	dirPath := util.FullPath(dir.FullPath())
-	glog.V(4).Infof("dir ReadDirAll %s", dirPath)
-
-	processEachEntryFn := func(entry *filer.Entry, isLast bool) {
-		if entry.IsDirectory() {
-			dirent := fuse.Dirent{Name: entry.Name(), Type: fuse.DT_Dir, Inode: dirPath.Child(entry.Name()).AsInode(os.ModeDir)}
-			ret = append(ret, dirent)
-		} else {
-			dirent := fuse.Dirent{Name: entry.Name(), Type: findFileType(uint16(entry.Attr.Mode)), Inode: dirPath.Child(entry.Name()).AsInode(entry.Attr.Mode)}
-			ret = append(ret, dirent)
-		}
-	}
-
-	if err = meta_cache.EnsureVisited(dir.wfs.metaCache, dir.wfs, dirPath); err != nil {
-		glog.Errorf("dir ReadDirAll %s: %v", dirPath, err)
-		return nil, fuse.EIO
-	}
-	listErr := dir.wfs.metaCache.ListDirectoryEntries(context.Background(), dirPath, "", false, int64(math.MaxInt32), func(entry *filer.Entry) bool {
-		processEachEntryFn(entry, false)
-		return true
-	})
-	if listErr != nil {
-		glog.Errorf("list meta cache: %v", listErr)
-		return nil, fuse.EIO
-	}
-
-	// create proper . and .. directories
-	ret = append(ret, fuse.Dirent{
-		Inode: dirPath.AsInode(os.ModeDir),
-		Name:  ".",
-		Type:  fuse.DT_Dir,
-	})
-
-	// return the correct parent inode for the mount root
-	var inode uint64
-	if string(dirPath) == dir.wfs.option.FilerMountRootPath {
-		inode = dir.wfs.option.MountParentInode
-	} else {
-		inode = util.FullPath(dir.parent.FullPath()).AsInode(os.ModeDir)
-	}
-
-	ret = append(ret, fuse.Dirent{
-		Inode: inode,
-		Name:  "..",
-		Type:  fuse.DT_Dir,
-	})
-
-	return
-}
-
-func findFileType(mode uint16) fuse.DirentType {
-	switch mode & (syscall.S_IFMT & 0xffff) {
-	case syscall.S_IFSOCK:
-		return fuse.DT_Socket
-	case syscall.S_IFLNK:
-		return fuse.DT_Link
-	case syscall.S_IFREG:
-		return fuse.DT_File
-	case syscall.S_IFBLK:
-		return fuse.DT_Block
-	case syscall.S_IFDIR:
-		return fuse.DT_Dir
-	case syscall.S_IFCHR:
-		return fuse.DT_Char
-	case syscall.S_IFIFO:
-		return fuse.DT_FIFO
-	}
-	return fuse.DT_File
-}
-
-func (dir *Dir) Remove(ctx context.Context, req *fuse.RemoveRequest) error {
-
-	parentHasPermission := false
-	parentEntry, err := dir.maybeLoadEntry()
-	if err != nil {
-		return err
-	}
-	if err := checkPermission(parentEntry, req.Uid, req.Gid, true); err == nil {
-		parentHasPermission = true
-	}
-
-	dirFullPath := dir.FullPath()
-	filePath := util.NewFullPath(dirFullPath, req.Name)
-	entry, err := filer_pb.GetEntry(dir.wfs, filePath)
-	if err != nil {
-		return err
-	}
-	if !parentHasPermission {
-		if err := checkPermission(entry, req.Uid, req.Gid, true); err != nil {
-			return err
-		}
-	}
-
-	if !req.Dir {
-		return dir.removeOneFile(entry, req)
-	}
-
-	return dir.removeFolder(entry, req)
-
-}
-
-func (dir *Dir) removeOneFile(entry *filer_pb.Entry, req *fuse.RemoveRequest) error {
-
-	dirFullPath := dir.FullPath()
-	filePath := util.NewFullPath(dirFullPath, req.Name)
-
-	// first, ensure the filer store can correctly delete
-	glog.V(3).Infof("remove file: %v", req)
-	isDeleteData := entry != nil && entry.HardLinkCounter <= 1
-	err := filer_pb.Remove(dir.wfs, dirFullPath, req.Name, isDeleteData, false, false, false, []int32{dir.wfs.signature})
-	if err != nil {
-		glog.V(3).Infof("not found remove file %s: %v", filePath, err)
-		return fuse.ENOENT
-	}
-
-	// then, delete meta cache and fsNode cache
-	if err = dir.wfs.metaCache.DeleteEntry(context.Background(), filePath); err != nil {
-		glog.V(3).Infof("local DeleteEntry %s: %v", filePath, err)
-		return fuse.ESTALE
-	}
-
-	// remove current file handle if any
-	dir.wfs.handlesLock.Lock()
-	defer dir.wfs.handlesLock.Unlock()
-	inodeId := filePath.AsInode(0)
-	if fh, ok := dir.wfs.handles[inodeId]; ok {
-		delete(dir.wfs.handles, inodeId)
-		fh.isDeleted = true
-	}
-
-	return nil
-
-}
-
-func (dir *Dir) removeFolder(entry *filer_pb.Entry, req *fuse.RemoveRequest) error {
-
-	dirFullPath := dir.FullPath()
-
-	glog.V(3).Infof("remove directory entry: %v", req)
-	ignoreRecursiveErr := false // ignore recursion error since the OS should manage it
-	err := filer_pb.Remove(dir.wfs, dirFullPath, req.Name, true, false, ignoreRecursiveErr, false, []int32{dir.wfs.signature})
-	if err != nil {
-		glog.V(0).Infof("remove %s/%s: %v", dirFullPath, req.Name, err)
-		if strings.Contains(err.Error(), filer.MsgFailDelNonEmptyFolder) {
-			return fuse.EEXIST
-		}
-		return fuse.ENOENT
-	}
-
-	t := util.NewFullPath(dirFullPath, req.Name)
-	dir.wfs.metaCache.DeleteEntry(context.Background(), t)
-
-	return nil
-
-}
-
-func (dir *Dir) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) error {
-
-	glog.V(4).Infof("%v dir setattr %+v mode=%d", dir.FullPath(), req, req.Mode)
-
-	entry, err := dir.maybeLoadEntry()
-	if err != nil {
-		return err
-	}
-
-	if req.Valid.Mode() {
-		entry.Attributes.FileMode = uint32(req.Mode)
-	}
-
-	if req.Valid.Uid() {
-		entry.Attributes.Uid = req.Uid
-	}
-
-	if req.Valid.Gid() {
-		entry.Attributes.Gid = req.Gid
-	}
-
-	if req.Valid.Mtime() {
-		entry.Attributes.Mtime = req.Mtime.Unix()
-	}
-
-	entry.Attributes.Mtime = time.Now().Unix()
-
-	return dir.saveEntry(entry)
-
-}
-
-func (dir *Dir) Setxattr(ctx context.Context, req *fuse.SetxattrRequest) error {
-
-	glog.V(4).Infof("dir Setxattr %s: %s", dir.FullPath(), req.Name)
-
-	entry, err := dir.maybeLoadEntry()
-	if err != nil {
-		return err
-	}
-
-	if err := setxattr(entry, req); err != nil {
-		return err
-	}
-
-	return dir.saveEntry(entry)
-
-}
-
-func (dir *Dir) Removexattr(ctx context.Context, req *fuse.RemovexattrRequest) error {
-
-	glog.V(4).Infof("dir Removexattr %s: %s", dir.FullPath(), req.Name)
-
-	entry, err := dir.maybeLoadEntry()
-	if err != nil {
-		return err
-	}
-
-	if err := removexattr(entry, req); err != nil {
-		return err
-	}
-
-	return dir.saveEntry(entry)
-
-}
-
-func (dir *Dir) Listxattr(ctx context.Context, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
-
-	glog.V(4).Infof("dir Listxattr %s", dir.FullPath())
-
-	entry, err := dir.maybeLoadEntry()
-	if err != nil {
-		return err
-	}
-
-	if err := listxattr(entry, req, resp); err != nil {
-		return err
-	}
-
-	return nil
-
-}
-
-func (dir *Dir) Forget() {
-	glog.V(4).Infof("Forget dir %s", dir.FullPath())
-}
-
-func (dir *Dir) maybeLoadEntry() (*filer_pb.Entry, error) {
-	parentDirPath, name := util.FullPath(dir.FullPath()).DirAndName()
-	return dir.wfs.maybeLoadEntry(parentDirPath, name)
-}
-
-func (dir *Dir) saveEntry(entry *filer_pb.Entry) error {
-
-	parentDir, name := util.FullPath(dir.FullPath()).DirAndName()
-
-	return dir.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		dir.wfs.mapPbIdFromLocalToFiler(entry)
-		defer dir.wfs.mapPbIdFromFilerToLocal(entry)
-
-		request := &filer_pb.UpdateEntryRequest{
-			Directory:  parentDir,
-			Entry:      entry,
-			Signatures: []int32{dir.wfs.signature},
-		}
-
-		glog.V(1).Infof("save dir entry: %v", request)
-		_, err := client.UpdateEntry(context.Background(), request)
-		if err != nil {
-			glog.Errorf("UpdateEntry dir %s/%s: %v", parentDir, name, err)
-			return fuse.EIO
-		}
-
-		if err := dir.wfs.metaCache.UpdateEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry)); err != nil {
-			glog.Errorf("UpdateEntry dir %s/%s: %v", parentDir, name, err)
-			return fuse.ESTALE
-		}
-
-		return nil
-	})
-}
-
-func (dir *Dir) FullPath() string {
-	var parts []string
-	for p := dir; p != nil; p = p.parent {
-		if strings.HasPrefix(p.name, "/") {
-			if len(p.name) > 1 {
-				parts = append(parts, p.name[1:])
-			}
-		} else {
-			parts = append(parts, p.name)
-		}
-	}
-
-	if len(parts) == 0 {
-		return "/"
-	}
-
-	var buf bytes.Buffer
-	for i := len(parts) - 1; i >= 0; i-- {
-		buf.WriteString("/")
-		buf.WriteString(parts[i])
-	}
-	return buf.String()
-}
@@ -1,169 +0,0 @@
-package filesys
-
-import (
-	"context"
-	"github.com/chrislusf/seaweedfs/weed/util"
-	"os"
-	"syscall"
-	"time"
-
-	"github.com/chrislusf/seaweedfs/weed/filer"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-)
-
-var _ = fs.NodeLinker(&Dir{})
-var _ = fs.NodeSymlinker(&Dir{})
-var _ = fs.NodeReadlinker(&File{})
-
-const (
-	HARD_LINK_MARKER = '\x01'
-)
-
-func (dir *Dir) Link(ctx context.Context, req *fuse.LinkRequest, old fs.Node) (fs.Node, error) {
-
-	if err := checkName(req.NewName); err != nil {
-		return nil, err
-	}
-
-	oldFile, ok := old.(*File)
-	if !ok {
-		glog.Errorf("old node is not a file: %+v", old)
-	}
-
-	glog.V(4).Infof("Link: %v/%v -> %v/%v", oldFile.dir.FullPath(), oldFile.Name, dir.FullPath(), req.NewName)
-
-	oldEntry, err := oldFile.maybeLoadEntry(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if oldEntry == nil {
-		return nil, fuse.EIO
-	}
-
-	// update old file to hardlink mode
-	if len(oldEntry.HardLinkId) == 0 {
-		oldEntry.HardLinkId = append(util.RandomBytes(16), HARD_LINK_MARKER)
-		oldEntry.HardLinkCounter = 1
-	}
-	oldEntry.HardLinkCounter++
-	updateOldEntryRequest := &filer_pb.UpdateEntryRequest{
-		Directory:  oldFile.dir.FullPath(),
-		Entry:      oldEntry,
-		Signatures: []int32{dir.wfs.signature},
-	}
-
-	// CreateLink 1.2 : update new file to hardlink mode
-	oldEntry.Attributes.Mtime = time.Now().Unix()
-	request := &filer_pb.CreateEntryRequest{
-		Directory: dir.FullPath(),
-		Entry: &filer_pb.Entry{
-			Name:            req.NewName,
-			IsDirectory:     false,
-			Attributes:      oldEntry.Attributes,
-			Chunks:          oldEntry.Chunks,
-			Extended:        oldEntry.Extended,
-			HardLinkId:      oldEntry.HardLinkId,
-			HardLinkCounter: oldEntry.HardLinkCounter,
-		},
-		Signatures: []int32{dir.wfs.signature},
-	}
-
-	// apply changes to the filer, and also apply to local metaCache
-	err = dir.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		dir.wfs.mapPbIdFromLocalToFiler(request.Entry)
-		defer dir.wfs.mapPbIdFromFilerToLocal(request.Entry)
-
-		if err := filer_pb.UpdateEntry(client, updateOldEntryRequest); err != nil {
-			glog.V(0).Infof("Link %v/%v -> %s/%s: %v", oldFile.dir.FullPath(), oldFile.Name, dir.FullPath(), req.NewName, err)
-			return fuse.EIO
-		}
-		dir.wfs.metaCache.UpdateEntry(context.Background(), filer.FromPbEntry(updateOldEntryRequest.Directory, updateOldEntryRequest.Entry))
-
-		if err := filer_pb.CreateEntry(client, request); err != nil {
-			glog.V(0).Infof("Link %v/%v -> %s/%s: %v", oldFile.dir.FullPath(), oldFile.Name, dir.FullPath(), req.NewName, err)
-			return fuse.EIO
-		}
-		dir.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry))
-
-		return nil
-	})
-
-	if err != nil {
-		return nil, fuse.EIO
-	}
-
-	// create new file node
-	newNode := dir.newFile(req.NewName, 0)
-	newFile := newNode.(*File)
-
-	return newFile, err
-
-}
-
-func (dir *Dir) Symlink(ctx context.Context, req *fuse.SymlinkRequest) (fs.Node, error) {
-
-	if err := checkName(req.NewName); err != nil {
-		return nil, err
-	}
-
-	glog.V(4).Infof("Symlink: %v/%v to %v", dir.FullPath(), req.NewName, req.Target)
-
-	request := &filer_pb.CreateEntryRequest{
-		Directory: dir.FullPath(),
-		Entry: &filer_pb.Entry{
-			Name:        req.NewName,
-			IsDirectory: false,
-			Attributes: &filer_pb.FuseAttributes{
-				Mtime:         time.Now().Unix(),
-				Crtime:        time.Now().Unix(),
-				FileMode:      uint32((os.FileMode(0777) | os.ModeSymlink) &^ dir.wfs.option.Umask),
-				Uid:           req.Uid,
-				Gid:           req.Gid,
-				SymlinkTarget: req.Target,
-			},
-		},
-		Signatures: []int32{dir.wfs.signature},
-	}
-
-	err := dir.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		dir.wfs.mapPbIdFromLocalToFiler(request.Entry)
-		defer dir.wfs.mapPbIdFromFilerToLocal(request.Entry)
-
-		if err := filer_pb.CreateEntry(client, request); err != nil {
-			glog.V(0).Infof("symlink %s/%s: %v", dir.FullPath(), req.NewName, err)
-			return fuse.EIO
-		}
-
-		dir.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry))
-
-		return nil
-	})
-
-	symlink := dir.newFile(req.NewName, os.ModeSymlink)
-
-	return symlink, err
-
-}
-
-func (file *File) Readlink(ctx context.Context, req *fuse.ReadlinkRequest) (string, error) {
-
-	entry, err := file.maybeLoadEntry(ctx)
-	if err != nil {
-		return "", err
-	}
-
-	if os.FileMode(entry.Attributes.FileMode)&os.ModeSymlink == 0 {
-		return "", fuse.Errno(syscall.EINVAL)
-	}
-
-	glog.V(4).Infof("Readlink: %v/%v => %v", file.dir.FullPath(), file.Name, entry.Attributes.SymlinkTarget)
-
-	return entry.Attributes.SymlinkTarget, nil
-
-}
@@ -1,149 +0,0 @@
-package filesys
-
-import (
-	"context"
-	"github.com/chrislusf/seaweedfs/weed/filer"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/chrislusf/seaweedfs/weed/util"
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-	"io"
-	"os"
-	"strings"
-)
-
-func (dir *Dir) Rename(ctx context.Context, req *fuse.RenameRequest, newDirectory fs.Node) error {
-
-	if err := checkName(req.NewName); err != nil {
-		return err
-	}
-	if err := checkName(req.OldName); err != nil {
-		return err
-	}
-
-	newDir := newDirectory.(*Dir)
-
-	newPath := util.NewFullPath(newDir.FullPath(), req.NewName)
-	oldPath := util.NewFullPath(dir.FullPath(), req.OldName)
-
-	glog.V(4).Infof("dir Rename %s => %s", oldPath, newPath)
-
-	// update remote filer
-	err := dir.wfs.WithFilerClient(true, func(client filer_pb.SeaweedFilerClient) error {
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-
-		request := &filer_pb.StreamRenameEntryRequest{
-			OldDirectory: dir.FullPath(),
-			OldName:      req.OldName,
-			NewDirectory: newDir.FullPath(),
-			NewName:      req.NewName,
-			Signatures:   []int32{dir.wfs.signature},
-		}
-
-		stream, err := client.StreamRenameEntry(ctx, request)
-		if err != nil {
-			glog.Errorf("dir AtomicRenameEntry %s => %s : %v", oldPath, newPath, err)
-			return fuse.EIO
-		}
-
-		for {
-			resp, recvErr := stream.Recv()
-			if recvErr != nil {
-				if recvErr == io.EOF {
-					break
-				} else {
-					glog.V(0).Infof("dir Rename %s => %s receive: %v", oldPath, newPath, recvErr)
-					if strings.Contains(recvErr.Error(), "not empty") {
-						return fuse.EEXIST
-					}
-					if strings.Contains(recvErr.Error(), "not directory") {
-						return fuse.ENOTDIR
-					}
-					return recvErr
-				}
-			}
-
-			if err = dir.handleRenameResponse(ctx, resp); err != nil {
-				glog.V(0).Infof("dir Rename %s => %s : %v", oldPath, newPath, err)
-				return err
-			}
-
-		}
-
-		return nil
-
-	})
-
-	return err
-}
-
-func (dir *Dir) handleRenameResponse(ctx context.Context, resp *filer_pb.StreamRenameEntryResponse) error {
-	// comes from filer StreamRenameEntry, can only be create or delete entry
-
-	if resp.EventNotification.NewEntry != nil {
-		// with new entry, the old entry name also exists. This is the first step to create new entry
-		newEntry := filer.FromPbEntry(resp.EventNotification.NewParentPath, resp.EventNotification.NewEntry)
-		if err := dir.wfs.metaCache.AtomicUpdateEntryFromFiler(ctx, "", newEntry); err != nil {
-			return err
-		}
-
-		oldParent, newParent := util.FullPath(resp.Directory), util.FullPath(resp.EventNotification.NewParentPath)
-		oldName, newName := resp.EventNotification.OldEntry.Name, resp.EventNotification.NewEntry.Name
-
-		entryFileMode := newEntry.Attr.Mode
-
-		oldPath := oldParent.Child(oldName)
-		newPath := newParent.Child(newName)
-		oldFsNode := NodeWithId(oldPath.AsInode(entryFileMode))
-		newFsNode := NodeWithId(newPath.AsInode(entryFileMode))
-		newDirNode, found := dir.wfs.Server.FindInternalNode(NodeWithId(newParent.AsInode(os.ModeDir)))
-		var newDir *Dir
-		if found {
-			newDir = newDirNode.(*Dir)
-		}
-		dir.wfs.Server.InvalidateInternalNode(oldFsNode, newFsNode, func(internalNode fs.Node) {
-			if file, ok := internalNode.(*File); ok {
-				glog.V(4).Infof("internal file node %s", oldParent.Child(oldName))
-				file.Name = newName
-				file.id = uint64(newFsNode)
-				if found {
-					file.dir = newDir
-				}
-			}
-			if dir, ok := internalNode.(*Dir); ok {
-				glog.V(4).Infof("internal dir node %s", oldParent.Child(oldName))
-				dir.name = newName
-				dir.id = uint64(newFsNode)
-				if found {
-					dir.parent = newDir
-				}
-			}
-		})
-
-		// change file handle
-		if !newEntry.IsDirectory() {
-			inodeId := oldPath.AsInode(entryFileMode)
-			dir.wfs.handlesLock.Lock()
-			if existingHandle, found := dir.wfs.handles[inodeId]; found && existingHandle != nil {
-				glog.V(4).Infof("opened file handle %s => %s", oldPath, newPath)
-				delete(dir.wfs.handles, inodeId)
-				existingHandle.handle = newPath.AsInode(entryFileMode)
-				existingHandle.f.entry.Name = newName
-				existingHandle.f.id = newPath.AsInode(entryFileMode)
-				dir.wfs.handles[newPath.AsInode(entryFileMode)] = existingHandle
-			}
-			dir.wfs.handlesLock.Unlock()
-		}
-
-	} else if resp.EventNotification.OldEntry != nil {
-		// without new entry, only old entry name exists. This is the second step to delete old entry
-		if err := dir.wfs.metaCache.AtomicUpdateEntryFromFiler(ctx, util.NewFullPath(resp.Directory, resp.EventNotification.OldEntry.Name), nil); err != nil {
-			return err
-		}
-	}
-
-	return nil
-
-}
@@ -1,101 +0,0 @@
-package filesys
-
-import (
-	"fmt"
-	"github.com/chrislusf/seaweedfs/weed/filesys/page_writer"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"io"
-	"sync"
-	"time"
-)
-
-type MemoryChunkPages struct {
-	fh             *FileHandle
-	writeWaitGroup sync.WaitGroup
-	chunkAddLock   sync.Mutex
-	lastErr        error
-	collection     string
-	replication    string
-	uploadPipeline *page_writer.UploadPipeline
-	hasWrites      bool
-}
-
-var (
-	_ = page_writer.DirtyPages(&MemoryChunkPages{})
-)
-
-func newMemoryChunkPages(fh *FileHandle, chunkSize int64) *MemoryChunkPages {
-
-	dirtyPages := &MemoryChunkPages{
-		fh: fh,
-	}
-
-	dirtyPages.uploadPipeline = page_writer.NewUploadPipeline(fh.f.fullpath(),
-		fh.f.wfs.concurrentWriters, chunkSize, dirtyPages.saveChunkedFileIntevalToStorage)
-
-	return dirtyPages
-}
-
-func (pages *MemoryChunkPages) AddPage(offset int64, data []byte) {
-	pages.hasWrites = true
-
-	glog.V(4).Infof("%v memory AddPage [%d, %d)", pages.fh.f.fullpath(), offset, offset+int64(len(data)))
-	pages.uploadPipeline.SaveDataAt(data, offset)
-
-	return
-}
-
-func (pages *MemoryChunkPages) FlushData() error {
-	if !pages.hasWrites {
-		return nil
-	}
-	pages.uploadPipeline.FlushAll()
-	if pages.lastErr != nil {
-		return fmt.Errorf("flush data: %v", pages.lastErr)
-	}
-	return nil
-}
-
-func (pages *MemoryChunkPages) ReadDirtyDataAt(data []byte, startOffset int64) (maxStop int64) {
-	if !pages.hasWrites {
-		return
-	}
-	return pages.uploadPipeline.MaybeReadDataAt(data, startOffset)
-}
-
-func (pages *MemoryChunkPages) GetStorageOptions() (collection, replication string) {
-	return pages.collection, pages.replication
-}
-
-func (pages *MemoryChunkPages) saveChunkedFileIntevalToStorage(reader io.Reader, offset int64, size int64, cleanupFn func()) {
-
-	mtime := time.Now().UnixNano()
-	defer cleanupFn()
-
-	chunk, collection, replication, err := pages.fh.f.wfs.saveDataAsChunk(pages.fh.f.fullpath())(reader, pages.fh.f.Name, offset)
-	if err != nil {
-		glog.V(0).Infof("%s saveToStorage [%d,%d): %v", pages.fh.f.fullpath(), offset, offset+size, err)
-		pages.lastErr = err
-		return
-	}
-	chunk.Mtime = mtime
-	pages.collection, pages.replication = collection, replication
-	pages.chunkAddLock.Lock()
-	pages.fh.f.addChunks([]*filer_pb.FileChunk{chunk})
-	pages.fh.entryViewCache = nil
-	glog.V(3).Infof("%s saveToStorage %s [%d,%d)", pages.fh.f.fullpath(), chunk.FileId, offset, offset+size)
-	pages.chunkAddLock.Unlock()
-
-}
-
-func (pages MemoryChunkPages) Destroy() {
-	pages.uploadPipeline.Shutdown()
-}
-
-func (pages *MemoryChunkPages) LockForRead(startOffset, stopOffset int64) {
-	pages.uploadPipeline.LockForRead(startOffset, stopOffset)
-}
-func (pages *MemoryChunkPages) UnlockForRead(startOffset, stopOffset int64) {
-	pages.uploadPipeline.UnlockForRead(startOffset, stopOffset)
-}
@@ -1,112 +0,0 @@
-package filesys
-
-import (
-	"fmt"
-	"github.com/chrislusf/seaweedfs/weed/filesys/page_writer"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"io"
-	"os"
-	"sync"
-	"time"
-)
-
-type TempFileDirtyPages struct {
-	f              *File
-	writeWaitGroup sync.WaitGroup
-	pageAddLock    sync.Mutex
-	chunkAddLock   sync.Mutex
-	lastErr        error
-	collection     string
-	replication    string
-	chunkedFile    *page_writer.ChunkedFileWriter
-}
-
-func newTempFileDirtyPages(file *File, chunkSize int64) *TempFileDirtyPages {
-
-	tempFile := &TempFileDirtyPages{
-		f:           file,
-		chunkedFile: page_writer.NewChunkedFileWriter(file.wfs.option.getTempFilePageDir(), chunkSize),
-	}
-
-	return tempFile
-}
-
-func (pages *TempFileDirtyPages) AddPage(offset int64, data []byte) {
-
-	pages.pageAddLock.Lock()
-	defer pages.pageAddLock.Unlock()
-
-	glog.V(4).Infof("%v tempfile AddPage [%d, %d)", pages.f.fullpath(), offset, offset+int64(len(data)))
-	if _, err := pages.chunkedFile.WriteAt(data, offset); err != nil {
-		pages.lastErr = err
-	}
-
-	return
-}
-
-func (pages *TempFileDirtyPages) FlushData() error {
-	pages.saveChunkedFileToStorage()
-	pages.writeWaitGroup.Wait()
-	if pages.lastErr != nil {
-		return fmt.Errorf("flush data: %v", pages.lastErr)
-	}
-	pages.chunkedFile.Reset()
-	return nil
-}
-
-func (pages *TempFileDirtyPages) ReadDirtyDataAt(data []byte, startOffset int64) (maxStop int64) {
-	return pages.chunkedFile.ReadDataAt(data, startOffset)
-}
-
-func (pages *TempFileDirtyPages) GetStorageOptions() (collection, replication string) {
-	return pages.collection, pages.replication
-}
-
-func (pages *TempFileDirtyPages) saveChunkedFileToStorage() {
-
-	pages.chunkedFile.ProcessEachInterval(func(file *os.File, logicChunkIndex page_writer.LogicChunkIndex, interval *page_writer.ChunkWrittenInterval) {
-		reader := page_writer.NewFileIntervalReader(pages.chunkedFile, logicChunkIndex, interval)
-		pages.saveChunkedFileIntevalToStorage(reader, int64(logicChunkIndex)*pages.chunkedFile.ChunkSize+interval.StartOffset, interval.Size())
-	})
-
-}
-
-func (pages *TempFileDirtyPages) saveChunkedFileIntevalToStorage(reader io.Reader, offset int64, size int64) {
-
-	mtime := time.Now().UnixNano()
-	pages.writeWaitGroup.Add(1)
-	writer := func() {
-		defer pages.writeWaitGroup.Done()
-
-		chunk, collection, replication, err := pages.f.wfs.saveDataAsChunk(pages.f.fullpath())(reader, pages.f.Name, offset)
-		if err != nil {
-			glog.V(0).Infof("%s saveToStorage [%d,%d): %v", pages.f.fullpath(), offset, offset+size, err)
-			pages.lastErr = err
-			return
-		}
-		chunk.Mtime = mtime
-		pages.collection, pages.replication = collection, replication
-		pages.chunkAddLock.Lock()
-		defer pages.chunkAddLock.Unlock()
-		pages.f.addChunks([]*filer_pb.FileChunk{chunk})
-		glog.V(3).Infof("%s saveToStorage %s [%d,%d)", pages.f.fullpath(), chunk.FileId, offset, offset+size)
-	}
-
-	if pages.f.wfs.concurrentWriters != nil {
-		pages.f.wfs.concurrentWriters.Execute(writer)
-	} else {
-		go writer()
-	}
-
-}
-
-func (pages TempFileDirtyPages) Destroy() {
-	pages.chunkedFile.Reset()
-}
-
-func (pages *TempFileDirtyPages) LockForRead(startOffset, stopOffset int64) {
-}
-
-func (pages *TempFileDirtyPages) UnlockForRead(startOffset, stopOffset int64) {
-}
@@ -1,406 +0,0 @@
-package filesys
-
-import (
-	"context"
-	"os"
-	"sort"
-	"time"
-
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-
-	"github.com/chrislusf/seaweedfs/weed/filer"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/chrislusf/seaweedfs/weed/util"
-)
-
-const blockSize = 512
-
-var _ = fs.Node(&File{})
-var _ = fs.NodeIdentifier(&File{})
-var _ = fs.NodeOpener(&File{})
-var _ = fs.NodeFsyncer(&File{})
-var _ = fs.NodeSetattrer(&File{})
-var _ = fs.NodeGetxattrer(&File{})
-var _ = fs.NodeSetxattrer(&File{})
-var _ = fs.NodeRemovexattrer(&File{})
-var _ = fs.NodeListxattrer(&File{})
-var _ = fs.NodeForgetter(&File{})
-
-type File struct {
-	Name          string
-	dir           *Dir
-	wfs           *WFS
-	entry         *filer_pb.Entry
-	isOpen        int
-	dirtyMetadata bool
-	id            uint64
-}
-
-func (file *File) fullpath() util.FullPath {
-	return util.NewFullPath(file.dir.FullPath(), file.Name)
-}
-
-func (file *File) Id() uint64 {
-	return file.id
-}
-
-func (file *File) Attr(ctx context.Context, attr *fuse.Attr) (err error) {
-
-	glog.V(4).Infof("file Attr %s, open:%v existing:%v", file.fullpath(), file.isOpen, attr)
-
-	entry, err := file.maybeLoadEntry(ctx)
-	if err != nil {
-		return err
-	}
-
-	if entry == nil {
-		return fuse.ENOENT
-	}
-
-	attr.Inode = file.Id()
-	attr.Valid = time.Second
-	attr.Mode = os.FileMode(entry.Attributes.FileMode)
-	attr.Size = filer.FileSize(entry)
-	if file.isOpen > 0 {
-		attr.Size = entry.Attributes.FileSize
-		glog.V(4).Infof("file Attr %s, open:%v, size: %d", file.fullpath(), file.isOpen, attr.Size)
-	}
-	attr.Crtime = time.Unix(entry.Attributes.Crtime, 0)
-	attr.Ctime = time.Unix(entry.Attributes.Mtime, 0)
-	attr.Mtime = time.Unix(entry.Attributes.Mtime, 0)
-	attr.Gid = entry.Attributes.Gid
-	attr.Uid = entry.Attributes.Uid
-	attr.Blocks = attr.Size/blockSize + 1
-	attr.BlockSize = uint32(file.wfs.option.ChunkSizeLimit)
-	if entry.HardLinkCounter > 0 {
-		attr.Nlink = uint32(entry.HardLinkCounter)
-	}
-
-	return nil
-
-}
-
-func (file *File) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, resp *fuse.GetxattrResponse) error {
-
-	// glog.V(4).Infof("file Getxattr %s", file.fullpath())
-
-	entry, err := file.maybeLoadEntry(ctx)
-	if err != nil {
-		return err
-	}
-
-	return getxattr(entry, req, resp)
-}
-
-func (file *File) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.OpenResponse) (fs.Handle, error) {
-
-	glog.V(4).Infof("file %v open %+v", file.fullpath(), req)
-	// resp.Flags |= fuse.OpenDirectIO
-
-	handle := file.wfs.AcquireHandle(file, req.Uid, req.Gid)
-
-	resp.Handle = fuse.HandleID(handle.handle)
-
-	glog.V(4).Infof("%v file open handle id = %d", file.fullpath(), handle.handle)
-
-	return handle, nil
-
-}
-
-func (file *File) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) error {
-
-	glog.V(4).Infof("%v file setattr %+v mode=%d", file.fullpath(), req, req.Mode)
-
-	entry, err := file.maybeLoadEntry(ctx)
-	if err != nil {
-		return err
-	}
-
-	if req.Valid.Size() {
-
-		glog.V(4).Infof("%v file setattr set size=%v chunks=%d", file.fullpath(), req.Size, len(entry.Chunks))
-		if req.Size < filer.FileSize(entry) {
-			// fmt.Printf("truncate %v \n", fullPath)
-			var chunks []*filer_pb.FileChunk
-			var truncatedChunks []*filer_pb.FileChunk
-			for _, chunk := range entry.Chunks {
-				int64Size := int64(chunk.Size)
-				if chunk.Offset+int64Size > int64(req.Size) {
-					// this chunk is truncated
-					int64Size = int64(req.Size) - chunk.Offset
-					if int64Size > 0 {
-						chunks = append(chunks, chunk)
-						glog.V(4).Infof("truncated chunk %+v from %d to %d\n", chunk.GetFileIdString(), chunk.Size, int64Size)
-						chunk.Size = uint64(int64Size)
-					} else {
-						glog.V(4).Infof("truncated whole chunk %+v\n", chunk.GetFileIdString())
-						truncatedChunks = append(truncatedChunks, chunk)
-					}
-				}
-			}
-			// set the new chunks and reset entry cache
-			entry.Chunks = chunks
-			file.wfs.handlesLock.Lock()
-			existingHandle, found := file.wfs.handles[file.Id()]
-			file.wfs.handlesLock.Unlock()
-			if found {
-				existingHandle.entryViewCache = nil
-			}
-
-		}
-		entry.Attributes.Mtime = time.Now().Unix()
-		entry.Attributes.FileSize = req.Size
-		file.dirtyMetadata = true
-	}
-
-	if req.Valid.Mode() && entry.Attributes.FileMode != uint32(req.Mode) {
-		entry.Attributes.FileMode = uint32(req.Mode)
-		entry.Attributes.Mtime = time.Now().Unix()
-		file.dirtyMetadata = true
-	}
-
-	if req.Valid.Uid() && entry.Attributes.Uid != req.Uid {
-		entry.Attributes.Uid = req.Uid
-		entry.Attributes.Mtime = time.Now().Unix()
-		file.dirtyMetadata = true
-	}
-
-	if req.Valid.Gid() && entry.Attributes.Gid != req.Gid {
-		entry.Attributes.Gid = req.Gid
-		entry.Attributes.Mtime = time.Now().Unix()
-		file.dirtyMetadata = true
-	}
-
-	if req.Valid.Crtime() {
-		entry.Attributes.Crtime = req.Crtime.Unix()
-		entry.Attributes.Mtime = time.Now().Unix()
-		file.dirtyMetadata = true
-	}
-
-	if req.Valid.Mtime() && entry.Attributes.Mtime != req.Mtime.Unix() {
-		entry.Attributes.Mtime = req.Mtime.Unix()
-		file.dirtyMetadata = true
-	}
-
-	if req.Valid.Handle() {
-		// fmt.Printf("file handle => %d\n", req.Handle)
-	}
-
-	if file.isOpen > 0 {
-		return nil
-	}
-
-	if !file.dirtyMetadata {
-		return nil
-	}
-
-	return file.saveEntry(entry)
-
-}
-
-func (file *File) Setxattr(ctx context.Context, req *fuse.SetxattrRequest) error {
-
-	glog.V(4).Infof("file Setxattr %s: %s", file.fullpath(), req.Name)
-
-	entry, err := file.maybeLoadEntry(ctx)
-	if err != nil {
-		return err
-	}
-
-	if err := setxattr(entry, req); err != nil {
-		return err
-	}
-	file.dirtyMetadata = true
-
-	if file.isOpen > 0 {
-		return nil
-	}
-
-	return file.saveEntry(entry)
-
-}
-
-func (file *File) Removexattr(ctx context.Context, req *fuse.RemovexattrRequest) error {
-
-	glog.V(4).Infof("file Removexattr %s: %s", file.fullpath(), req.Name)
-
-	entry, err := file.maybeLoadEntry(ctx)
-	if err != nil {
-		return err
-	}
-
-	if err := removexattr(entry, req); err != nil {
-		return err
-	}
-	file.dirtyMetadata = true
-
-	if file.isOpen > 0 {
-		return nil
-	}
-
-	return file.saveEntry(entry)
-
-}
-
-func (file *File) Listxattr(ctx context.Context, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
-
-	glog.V(4).Infof("file Listxattr %s", file.fullpath())
-
-	entry, err := file.maybeLoadEntry(ctx)
-	if err != nil {
-		return err
-	}
-
-	if err := listxattr(entry, req, resp); err != nil {
-		return err
-	}
-
-	return nil
-
-}
-
-func (file *File) Fsync(ctx context.Context, req *fuse.FsyncRequest) error {
-
-	// write the file chunks to the filerGrpcAddress
-	glog.V(4).Infof("%s/%s fsync file %+v", file.dir.FullPath(), file.Name, req)
-
-	return file.wfs.Fsync(file, req.Header)
-
-}
-
-func (file *File) Forget() {
-	t := util.NewFullPath(file.dir.FullPath(), file.Name)
-	glog.V(4).Infof("Forget file %s", t)
-	file.wfs.ReleaseHandle(t, fuse.HandleID(t.AsInode(file.entry.FileMode())))
-
-}
-
-func (file *File) maybeLoadEntry(ctx context.Context) (entry *filer_pb.Entry, err error) {
-
-	file.wfs.handlesLock.Lock()
-	handle, found := file.wfs.handles[file.Id()]
-	file.wfs.handlesLock.Unlock()
-	entry = file.entry
-	if found {
-		// glog.V(4).Infof("maybeLoadEntry found opened file %s/%s", file.dir.FullPath(), file.Name)
-		entry = handle.f.entry
-	}
-
-	if entry != nil {
-		if len(entry.HardLinkId) == 0 {
-			// only always reload hard link
-			return entry, nil
-		}
-	}
-	entry, err = file.wfs.maybeLoadEntry(file.dir.FullPath(), file.Name)
-	if err != nil {
-		glog.V(3).Infof("maybeLoadEntry file %s/%s: %v", file.dir.FullPath(), file.Name, err)
-		return entry, err
-	}
-	if entry != nil {
-		// file.entry = entry
-	} else {
-		glog.Warningf("maybeLoadEntry not found entry %s/%s: %v", file.dir.FullPath(), file.Name, err)
-	}
-	return entry, nil
-}
-
-func lessThan(a, b *filer_pb.FileChunk) bool {
-	if a.Mtime == b.Mtime {
-		return a.Fid.FileKey < b.Fid.FileKey
-	}
-	return a.Mtime < b.Mtime
-}
-
-func (file *File) addChunks(chunks []*filer_pb.FileChunk) {
-
-	// find the earliest incoming chunk
-	newChunks := chunks
-	earliestChunk := newChunks[0]
-	for i := 1; i < len(newChunks); i++ {
-		if lessThan(earliestChunk, newChunks[i]) {
-			earliestChunk = newChunks[i]
-		}
-	}
-
-	entry := file.getEntry()
-	if entry == nil {
-		return
-	}
-
-	// pick out-of-order chunks from existing chunks
-	for _, chunk := range entry.Chunks {
-		if lessThan(earliestChunk, chunk) {
-			chunks = append(chunks, chunk)
-		}
-	}
-
-	// sort incoming chunks
-	sort.Slice(chunks, func(i, j int) bool {
-		return lessThan(chunks[i], chunks[j])
-	})
-
-	glog.V(4).Infof("%s existing %d chunks adds %d more", file.fullpath(), len(entry.Chunks), len(chunks))
-
-	entry.Chunks = append(entry.Chunks, newChunks...)
-}
-
-func (file *File) saveEntry(entry *filer_pb.Entry) error {
-	return file.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		file.wfs.mapPbIdFromLocalToFiler(entry)
-		defer file.wfs.mapPbIdFromFilerToLocal(entry)
-
-		request := &filer_pb.CreateEntryRequest{
-			Directory:  file.dir.FullPath(),
-			Entry:      entry,
-			Signatures: []int32{file.wfs.signature},
-		}
-
-		glog.V(4).Infof("save file entry: %v", request)
-		_, err := client.CreateEntry(context.Background(), request)
-		if err != nil {
-			glog.Errorf("UpdateEntry file %s/%s: %v", file.dir.FullPath(), file.Name, err)
-			return fuse.EIO
-		}
-
-		file.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry))
-
-		file.dirtyMetadata = false
-
-		return nil
-	})
-}
-
-func (file *File) getEntry() *filer_pb.Entry {
-	return file.entry
-}
-
-func (file *File) downloadRemoteEntry(entry *filer_pb.Entry) (*filer_pb.Entry, error) {
-	err := file.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		request := &filer_pb.CacheRemoteObjectToLocalClusterRequest{
-			Directory: file.dir.FullPath(),
-			Name:      entry.Name,
-		}
-
-		glog.V(4).Infof("download entry: %v", request)
-		resp, err := client.CacheRemoteObjectToLocalCluster(context.Background(), request)
-		if err != nil {
-			glog.Errorf("CacheRemoteObjectToLocalCluster file %s/%s: %v", file.dir.FullPath(), file.Name, err)
-			return fuse.EIO
-		}
-
-		entry = resp.Entry
-
-		file.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, resp.Entry))
-
-		file.dirtyMetadata = false
-
-		return nil
-	})
-
-	return entry, err
-}
@@ -1,347 +0,0 @@
-package filesys
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math"
-	"net/http"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-
-	"github.com/chrislusf/seaweedfs/weed/filer"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-)
-
-type FileHandle struct {
-	// cache file has been written to
-	dirtyPages     *PageWriter
-	entryViewCache []filer.VisibleInterval
-	reader         io.ReaderAt
-	contentType    string
-	handle         uint64
-	sync.Mutex
-
-	f         *File
-	NodeId    fuse.NodeID // file or directory the request is about
-	Uid       uint32      // user ID of process making request
-	Gid       uint32      // group ID of process making request
-	isDeleted bool
-}
-
-func newFileHandle(file *File, uid, gid uint32) *FileHandle {
-	fh := &FileHandle{
-		f:   file,
-		Uid: uid,
-		Gid: gid,
-	}
-	// dirtyPages: newContinuousDirtyPages(file, writeOnly),
-	fh.dirtyPages = newPageWriter(fh, file.wfs.option.ChunkSizeLimit)
-	entry := fh.f.getEntry()
-	if entry != nil {
-		entry.Attributes.FileSize = filer.FileSize(entry)
-	}
-
-	return fh
-}
-
-var _ = fs.Handle(&FileHandle{})
-
-// var _ = fs.HandleReadAller(&FileHandle{})
-var _ = fs.HandleReader(&FileHandle{})
-var _ = fs.HandleFlusher(&FileHandle{})
-var _ = fs.HandleWriter(&FileHandle{})
-var _ = fs.HandleReleaser(&FileHandle{})
-
-func (fh *FileHandle) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
-
-	fh.Lock()
-	defer fh.Unlock()
-
-	glog.V(4).Infof("%s read fh %d: [%d,%d) size %d resp.Data cap=%d", fh.f.fullpath(), fh.handle, req.Offset, req.Offset+int64(req.Size), req.Size, cap(resp.Data))
-
-	if req.Size <= 0 {
-		return nil
-	}
-
-	buff := resp.Data[:cap(resp.Data)]
-	if req.Size > cap(resp.Data) {
-		// should not happen
-		buff = make([]byte, req.Size)
-	}
-
-	fh.lockForRead(req.Offset, len(buff))
-	defer fh.unlockForRead(req.Offset, len(buff))
-	totalRead, err := fh.readFromChunks(buff, req.Offset)
-	if err == nil || err == io.EOF {
-		maxStop := fh.readFromDirtyPages(buff, req.Offset)
-		totalRead = max(maxStop-req.Offset, totalRead)
-	}
-
-	if err == io.EOF {
-		err = nil
-	}
-
-	if err != nil {
-		glog.Warningf("file handle read %s %d: %v", fh.f.fullpath(), totalRead, err)
-		return fuse.EIO
-	}
-
-	if totalRead > int64(len(buff)) {
-		glog.Warningf("%s FileHandle Read %d: [%d,%d) size %d totalRead %d", fh.f.fullpath(), fh.handle, req.Offset, req.Offset+int64(req.Size), req.Size, totalRead)
-		totalRead = min(int64(len(buff)), totalRead)
-	}
-	if err == nil {
-		resp.Data = buff[:totalRead]
-	}
-
-	return err
-}
-
-func (fh *FileHandle) lockForRead(startOffset int64, size int) {
-	fh.dirtyPages.LockForRead(startOffset, startOffset+int64(size))
-}
-func (fh *FileHandle) unlockForRead(startOffset int64, size int) {
-	fh.dirtyPages.UnlockForRead(startOffset, startOffset+int64(size))
-}
-
-func (fh *FileHandle) readFromDirtyPages(buff []byte, startOffset int64) (maxStop int64) {
-	maxStop = fh.dirtyPages.ReadDirtyDataAt(buff, startOffset)
-	return
-}
-
-func (fh *FileHandle) readFromChunks(buff []byte, offset int64) (int64, error) {
-
-	entry := fh.f.getEntry()
-	if entry == nil {
-		return 0, io.EOF
-	}
-
-	if entry.IsInRemoteOnly() {
-		glog.V(4).Infof("download remote entry %s", fh.f.fullpath())
-		newEntry, err := fh.f.downloadRemoteEntry(entry)
-		if err != nil {
-			glog.V(1).Infof("download remote entry %s: %v", fh.f.fullpath(), err)
-			return 0, err
-		}
-		entry = newEntry
-	}
-
-	fileSize := int64(filer.FileSize(entry))
-	fileFullPath := fh.f.fullpath()
-
-	if fileSize == 0 {
-		glog.V(1).Infof("empty fh %v", fileFullPath)
-		return 0, io.EOF
-	}
-
-	if offset+int64(len(buff)) <= int64(len(entry.Content)) {
-		totalRead := copy(buff, entry.Content[offset:])
-		glog.V(4).Infof("file handle read cached %s [%d,%d] %d", fileFullPath, offset, offset+int64(totalRead), totalRead)
-		return int64(totalRead), nil
-	}
-
-	var chunkResolveErr error
-	if fh.entryViewCache == nil {
-		fh.entryViewCache, chunkResolveErr = filer.NonOverlappingVisibleIntervals(fh.f.wfs.LookupFn(), entry.Chunks, 0, math.MaxInt64)
-		if chunkResolveErr != nil {
-			return 0, fmt.Errorf("fail to resolve chunk manifest: %v", chunkResolveErr)
-		}
-		fh.reader = nil
-	}
-
-	reader := fh.reader
-	if reader == nil {
-		chunkViews := filer.ViewFromVisibleIntervals(fh.entryViewCache, 0, math.MaxInt64)
-		glog.V(4).Infof("file handle read %s [%d,%d) from %+v", fileFullPath, offset, offset+int64(len(buff)), chunkViews)
-		for _, chunkView := range chunkViews {
-			glog.V(4).Infof("  read %s [%d,%d) from chunk %+v", fileFullPath, chunkView.LogicOffset, chunkView.LogicOffset+int64(chunkView.Size), chunkView.FileId)
-		}
-		reader = filer.NewChunkReaderAtFromClient(fh.f.wfs.LookupFn(), chunkViews, fh.f.wfs.chunkCache, fileSize)
-	}
-	fh.reader = reader
-
-	totalRead, err := reader.ReadAt(buff, offset)
-
-	if err != nil && err != io.EOF {
-		glog.Errorf("file handle read %s: %v", fileFullPath, err)
-	}
-
-	glog.V(4).Infof("file handle read %s [%d,%d] %d : %v", fileFullPath, offset, offset+int64(totalRead), totalRead, err)
-
-	return int64(totalRead), err
-}
-
-// Write to the file handle
-func (fh *FileHandle) Write(ctx context.Context, req *fuse.WriteRequest, resp *fuse.WriteResponse) error {
-
-	fh.dirtyPages.writerPattern.MonitorWriteAt(req.Offset, len(req.Data))
-
-	fh.Lock()
-	defer fh.Unlock()
-
-	// write the request to volume servers
-	data := req.Data
-	if len(data) <= 512 && req.Offset == 0 {
-		// fuse message cacheable size
-		data = make([]byte, len(req.Data))
-		copy(data, req.Data)
-	}
-
-	entry := fh.f.getEntry()
-	if entry == nil {
-		return fuse.EIO
-	}
-
-	entry.Content = nil
-	entry.Attributes.FileSize = uint64(max(req.Offset+int64(len(data)), int64(entry.Attributes.FileSize)))
-	// glog.V(4).Infof("%v write [%d,%d) %d", fh.f.fullpath(), req.Offset, req.Offset+int64(len(req.Data)), len(req.Data))
-
-	fh.dirtyPages.AddPage(req.Offset, data)
-
-	resp.Size = len(data)
-
-	if req.Offset == 0 {
-		// detect mime type
-		fh.contentType = http.DetectContentType(data)
-		fh.f.dirtyMetadata = true
-	}
-
-	fh.f.dirtyMetadata = true
-
-	return nil
-}
-
-func (fh *FileHandle) Release(ctx context.Context, req *fuse.ReleaseRequest) error {
-
-	glog.V(4).Infof("Release %v fh %d open=%d", fh.f.fullpath(), fh.handle, fh.f.isOpen)
-
-	fh.f.wfs.handlesLock.Lock()
-	fh.f.isOpen--
-	fh.f.wfs.handlesLock.Unlock()
-
-	if fh.f.isOpen <= 0 {
-		fh.f.entry = nil
-		fh.entryViewCache = nil
-		fh.reader = nil
-
-		fh.f.wfs.ReleaseHandle(fh.f.fullpath(), fuse.HandleID(fh.handle))
-		fh.dirtyPages.Destroy()
-	}
-
-	if fh.f.isOpen < 0 {
-		glog.V(0).Infof("Release reset %s open count %d => %d", fh.f.Name, fh.f.isOpen, 0)
-		fh.f.isOpen = 0
-		return nil
-	}
-
-	return nil
-}
-
-func (fh *FileHandle) Flush(ctx context.Context, req *fuse.FlushRequest) error {
-
-	glog.V(4).Infof("Flush %v fh %d", fh.f.fullpath(), fh.handle)
-
-	if fh.isDeleted {
-		glog.V(4).Infof("Flush %v fh %d skip deleted", fh.f.fullpath(), fh.handle)
-		return nil
-	}
-
-	fh.Lock()
-	defer fh.Unlock()
-
-	if err := fh.doFlush(ctx, req.Header); err != nil {
-		glog.Errorf("Flush doFlush %s: %v", fh.f.Name, err)
-		return err
-	}
-
-	return nil
-}
-
-func (fh *FileHandle) doFlush(ctx context.Context, header fuse.Header) error {
-	// flush works at fh level
-	// send the data to the OS
-	glog.V(4).Infof("doFlush %s fh %d", fh.f.fullpath(), fh.handle)
-
-	if err := fh.dirtyPages.FlushData(); err != nil {
-		glog.Errorf("%v doFlush: %v", fh.f.fullpath(), err)
-		return fuse.EIO
-	}
-
-	if !fh.f.dirtyMetadata {
-		return nil
-	}
-
-	err := fh.f.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-		entry := fh.f.getEntry()
-		if entry == nil {
-			return nil
-		}
-
-		if entry.Attributes != nil {
-			entry.Attributes.Mime = fh.contentType
-			if entry.Attributes.Uid == 0 {
-				entry.Attributes.Uid = header.Uid
-			}
-			if entry.Attributes.Gid == 0 {
-				entry.Attributes.Gid = header.Gid
-			}
-			if entry.Attributes.Crtime == 0 {
-				entry.Attributes.Crtime = time.Now().Unix()
-			}
-			entry.Attributes.Mtime = time.Now().Unix()
-			entry.Attributes.FileMode = uint32(os.FileMode(entry.Attributes.FileMode) &^ fh.f.wfs.option.Umask)
-			entry.Attributes.Collection, entry.Attributes.Replication = fh.dirtyPages.GetStorageOptions()
-		}
-
-		request := &filer_pb.CreateEntryRequest{
-			Directory:  fh.f.dir.FullPath(),
-			Entry:      entry,
-			Signatures: []int32{fh.f.wfs.signature},
-		}
-
-		glog.V(4).Infof("%s set chunks: %v", fh.f.fullpath(), len(entry.Chunks))
-		for i, chunk := range entry.Chunks {
-			glog.V(4).Infof("%s chunks %d: %v [%d,%d)", fh.f.fullpath(), i, chunk.GetFileIdString(), chunk.Offset, chunk.Offset+int64(chunk.Size))
-		}
-
-		manifestChunks, nonManifestChunks := filer.SeparateManifestChunks(entry.Chunks)
-
-		chunks, _ := filer.CompactFileChunks(fh.f.wfs.LookupFn(), nonManifestChunks)
-		chunks, manifestErr := filer.MaybeManifestize(fh.f.wfs.saveDataAsChunk(fh.f.fullpath()), chunks)
-		if manifestErr != nil {
-			// not good, but should be ok
-			glog.V(0).Infof("MaybeManifestize: %v", manifestErr)
-		}
-		entry.Chunks = append(chunks, manifestChunks...)
-
-		fh.f.wfs.mapPbIdFromLocalToFiler(request.Entry)
-		defer fh.f.wfs.mapPbIdFromFilerToLocal(request.Entry)
-
-		if err := filer_pb.CreateEntry(client, request); err != nil {
-			glog.Errorf("fh flush create %s: %v", fh.f.fullpath(), err)
-			return fmt.Errorf("fh flush create %s: %v", fh.f.fullpath(), err)
-		}
-
-		fh.f.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, request.Entry))
-
-		return nil
-	})
-
-	if err == nil {
-		fh.f.dirtyMetadata = false
-	}
-
-	if err != nil {
-		glog.Errorf("%v fh %d flush: %v", fh.f.fullpath(), fh.handle, err)
-		return fuse.EIO
-	}
-
-	return nil
-}
@@ -1,213 +0,0 @@
-package filesys
-
-import (
-	"sync"
-
-	"github.com/seaweedfs/fuse/fs"
-
-	"github.com/chrislusf/seaweedfs/weed/util"
-)
-
-type FsCache struct {
-	root *FsNode
-	sync.RWMutex
-}
-type FsNode struct {
-	parent       *FsNode
-	node         fs.Node
-	name         string
-	childrenLock sync.RWMutex
-	children     map[string]*FsNode
-}
-
-func newFsCache(root fs.Node) *FsCache {
-	return &FsCache{
-		root: &FsNode{
-			node: root,
-		},
-	}
-}
-
-func (c *FsCache) GetFsNode(path util.FullPath) fs.Node {
-
-	c.RLock()
-	defer c.RUnlock()
-
-	return c.doGetFsNode(path)
-}
-
-func (c *FsCache) doGetFsNode(path util.FullPath) fs.Node {
-	t := c.root
-	for _, p := range path.Split() {
-		t = t.findChild(p)
-		if t == nil {
-			return nil
-		}
-	}
-	return t.node
-}
-
-func (c *FsCache) SetFsNode(path util.FullPath, node fs.Node) {
-
-	c.Lock()
-	defer c.Unlock()
-
-	c.doSetFsNode(path, node)
-}
-
-func (c *FsCache) doSetFsNode(path util.FullPath, node fs.Node) {
-	t := c.root
-	for _, p := range path.Split() {
-		t = t.ensureChild(p)
-	}
-	t.node = node
-}
-
-func (c *FsCache) EnsureFsNode(path util.FullPath, genNodeFn func() fs.Node) fs.Node {
-
-	c.Lock()
-	defer c.Unlock()
-
-	t := c.doGetFsNode(path)
-	if t != nil {
-		return t
-	}
-	t = genNodeFn()
-	c.doSetFsNode(path, t)
-	return t
-}
-
-func (c *FsCache) DeleteFsNode(path util.FullPath) {
-
-	c.Lock()
-	defer c.Unlock()
-
-	t := c.root
-	for _, p := range path.Split() {
-		t = t.findChild(p)
-		if t == nil {
-			return
-		}
-	}
-	if t.parent != nil {
-		t.parent.disconnectChild(t)
-	}
-	t.deleteSelf()
-}
-
-// oldPath and newPath are full path including the new name
-func (c *FsCache) Move(oldPath util.FullPath, newPath util.FullPath) *FsNode {
-
-	c.Lock()
-	defer c.Unlock()
-
-	// find old node
-	src := c.root
-	for _, p := range oldPath.Split() {
-		src = src.findChild(p)
-		if src == nil {
-			return src
-		}
-	}
-	if src.parent != nil {
-		src.parent.disconnectChild(src)
-	}
-
-	// find new node
-	target := c.root
-	for _, p := range newPath.Split() {
-		target = target.ensureChild(p)
-	}
-	parent := target.parent
-	if dir, ok := src.node.(*Dir); ok {
-		dir.name = target.name // target is not Dir, but a shortcut
-	}
-	if f, ok := src.node.(*File); ok {
-		f.Name = target.name
-		entry := f.getEntry()
-		if entry != nil {
-			entry.Name = f.Name
-		}
-	}
-	parent.disconnectChild(target)
-
-	target.deleteSelf()
-
-	src.name = target.name
-	src.connectToParent(parent)
-
-	return src
-}
-
-func (n *FsNode) connectToParent(parent *FsNode) {
-	n.parent = parent
-	oldNode := parent.findChild(n.name)
-	if oldNode != nil {
-		oldNode.deleteSelf()
-	}
-	if dir, ok := n.node.(*Dir); ok {
-		if parent.node != nil {
-			dir.parent = parent.node.(*Dir)
-		}
-	}
-	if f, ok := n.node.(*File); ok {
-		if parent.node != nil {
-			f.dir = parent.node.(*Dir)
-		}
-	}
-	n.childrenLock.Lock()
-	parent.children[n.name] = n
-	n.childrenLock.Unlock()
-}
-
-func (n *FsNode) findChild(name string) *FsNode {
-	n.childrenLock.RLock()
-	defer n.childrenLock.RUnlock()
-
-	child, found := n.children[name]
-	if found {
-		return child
-	}
-	return nil
-}
-
-func (n *FsNode) ensureChild(name string) *FsNode {
-	n.childrenLock.Lock()
-	defer n.childrenLock.Unlock()
-
-	if n.children == nil {
-		n.children = make(map[string]*FsNode)
-	}
-	child, found := n.children[name]
-	if found {
-		return child
-	}
-	t := &FsNode{
-		parent:   n,
-		node:     nil,
-		name:     name,
-		children: nil,
-	}
-	n.children[name] = t
-	return t
-}
-
-func (n *FsNode) disconnectChild(child *FsNode) {
-	n.childrenLock.Lock()
-	delete(n.children, child.name)
-	n.childrenLock.Unlock()
-	child.parent = nil
-}
-
-func (n *FsNode) deleteSelf() {
-	n.childrenLock.Lock()
-	for _, child := range n.children {
-		child.deleteSelf()
-	}
-	n.children = nil
-	n.childrenLock.Unlock()
-
-	n.node = nil
-	n.parent = nil
-
-}
@@ -1,115 +0,0 @@
-package filesys
-
-import (
-	"testing"
-
-	"github.com/chrislusf/seaweedfs/weed/util"
-)
-
-func TestPathSplit(t *testing.T) {
-	parts := util.FullPath("/").Split()
-	if len(parts) != 0 {
-		t.Errorf("expecting an empty list, but getting %d", len(parts))
-	}
-
-	parts = util.FullPath("/readme.md").Split()
-	if len(parts) != 1 {
-		t.Errorf("expecting an empty list, but getting %d", len(parts))
-	}
-
-}
-
-func TestFsCache(t *testing.T) {
-
-	cache := newFsCache(nil)
-
-	x := cache.GetFsNode(util.FullPath("/y/x"))
-	if x != nil {
-		t.Errorf("wrong node!")
-	}
-
-	p := util.FullPath("/a/b/c")
-	cache.SetFsNode(p, &File{Name: "cc"})
-	tNode := cache.GetFsNode(p)
-	tFile := tNode.(*File)
-	if tFile.Name != "cc" {
-		t.Errorf("expecting a FsNode")
-	}
-
-	cache.SetFsNode(util.FullPath("/a/b/d"), &File{Name: "dd"})
-	cache.SetFsNode(util.FullPath("/a/b/e"), &File{Name: "ee"})
-	cache.SetFsNode(util.FullPath("/a/b/f"), &File{Name: "ff"})
-	cache.SetFsNode(util.FullPath("/z"), &File{Name: "zz"})
-	cache.SetFsNode(util.FullPath("/a"), &File{Name: "aa"})
-
-	b := cache.GetFsNode(util.FullPath("/a/b"))
-	if b != nil {
-		t.Errorf("unexpected node!")
-	}
-
-	a := cache.GetFsNode(util.FullPath("/a"))
-	if a == nil {
-		t.Errorf("missing node!")
-	}
-
-	cache.DeleteFsNode(util.FullPath("/a"))
-	if b != nil {
-		t.Errorf("unexpected node!")
-	}
-
-	a = cache.GetFsNode(util.FullPath("/a"))
-	if a != nil {
-		t.Errorf("wrong DeleteFsNode!")
-	}
-
-	z := cache.GetFsNode(util.FullPath("/z"))
-	if z == nil {
-		t.Errorf("missing node!")
-	}
-
-	y := cache.GetFsNode(util.FullPath("/x/y"))
-	if y != nil {
-		t.Errorf("wrong node!")
-	}
-
-}
-
-func TestFsCacheMove(t *testing.T) {
-
-	cache := newFsCache(nil)
-
-	cache.SetFsNode(util.FullPath("/a/b/d"), &File{Name: "dd"})
-	cache.SetFsNode(util.FullPath("/a/b/e"), &File{Name: "ee"})
-	cache.SetFsNode(util.FullPath("/z"), &File{Name: "zz"})
-	cache.SetFsNode(util.FullPath("/a"), &File{Name: "aa"})
-
-	cache.Move(util.FullPath("/a/b"), util.FullPath("/z/x"))
-
-	d := cache.GetFsNode(util.FullPath("/z/x/d"))
-	if d == nil {
-		t.Errorf("unexpected nil node!")
-	}
-	if d.(*File).Name != "dd" {
-		t.Errorf("unexpected non dd node!")
-	}
-
-}
-
-func TestFsCacheMove2(t *testing.T) {
-
-	cache := newFsCache(nil)
-
-	cache.SetFsNode(util.FullPath("/a/b/d"), &File{Name: "dd"})
-	cache.SetFsNode(util.FullPath("/a/b/e"), &File{Name: "ee"})
-
-	cache.Move(util.FullPath("/a/b/d"), util.FullPath("/a/b/e"))
-
-	d := cache.GetFsNode(util.FullPath("/a/b/e"))
-	if d == nil {
-		t.Errorf("unexpected nil node!")
-	}
-	if d.(*File).Name != "e" {
-		t.Errorf("unexpected node!")
-	}
-
-}
@@ -1,47 +0,0 @@
-package meta_cache
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/chrislusf/seaweedfs/weed/filer"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/chrislusf/seaweedfs/weed/util"
-)
-
-func EnsureVisited(mc *MetaCache, client filer_pb.FilerClient, dirPath util.FullPath) error {
-
-	return mc.visitedBoundary.EnsureVisited(dirPath, func(path util.FullPath) (childDirectories []string, err error) {
-
-		glog.V(4).Infof("ReadDirAllEntries %s ...", path)
-
-		util.Retry("ReadDirAllEntries", func() error {
-			err = filer_pb.ReadDirAllEntries(client, path, "", func(pbEntry *filer_pb.Entry, isLast bool) error {
-				entry := filer.FromPbEntry(string(path), pbEntry)
-				if IsHiddenSystemEntry(string(path), entry.Name()) {
-					return nil
-				}
-				if err := mc.doInsertEntry(context.Background(), entry); err != nil {
-					glog.V(0).Infof("read %s: %v", entry.FullPath, err)
-					return err
-				}
-				if entry.IsDirectory() {
-					childDirectories = append(childDirectories, entry.Name())
-				}
-				return nil
-			})
-			return err
-		})
-
-		if err != nil {
-			err = fmt.Errorf("list %s: %v", path, err)
-		}
-
-		return
-	})
-}
-
-func IsHiddenSystemEntry(dir, name string) bool {
-	return dir == "/" && (name == "topics" || name == "etc")
-}
@@ -1,159 +0,0 @@
-package page_writer
-
-import (
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"io"
-	"os"
-	"sync"
-)
-
-type ActualChunkIndex int
-
-// ChunkedFileWriter assumes the write requests will come in within chunks
-type ChunkedFileWriter struct {
-	dir                     string
-	file                    *os.File
-	logicToActualChunkIndex map[LogicChunkIndex]ActualChunkIndex
-	chunkUsages             []*ChunkWrittenIntervalList
-	ChunkSize               int64
-	sync.Mutex
-}
-
-var _ = io.WriterAt(&ChunkedFileWriter{})
-
-func NewChunkedFileWriter(dir string, chunkSize int64) *ChunkedFileWriter {
-	return &ChunkedFileWriter{
-		dir:                     dir,
-		file:                    nil,
-		logicToActualChunkIndex: make(map[LogicChunkIndex]ActualChunkIndex),
-		ChunkSize:               chunkSize,
-	}
-}
-
-func (cw *ChunkedFileWriter) WriteAt(p []byte, off int64) (n int, err error) {
-	cw.Lock()
-	defer cw.Unlock()
-
-	if cw.file == nil {
-		cw.file, err = os.CreateTemp(cw.dir, "")
-		if err != nil {
-			glog.Errorf("create temp file: %v", err)
-			return
-		}
-	}
-
-	actualOffset, chunkUsage := cw.toActualWriteOffset(off)
-	n, err = cw.file.WriteAt(p, actualOffset)
-	if err == nil {
-		startOffset := off % cw.ChunkSize
-		chunkUsage.MarkWritten(startOffset, startOffset+int64(n))
-	}
-	return
-}
-
-func (cw *ChunkedFileWriter) ReadDataAt(p []byte, off int64) (maxStop int64) {
-	cw.Lock()
-	defer cw.Unlock()
-
-	if cw.file == nil {
-		return
-	}
-
-	logicChunkIndex := off / cw.ChunkSize
-	actualChunkIndex, chunkUsage := cw.toActualReadOffset(off)
-	if chunkUsage != nil {
-		for t := chunkUsage.head.next; t != chunkUsage.tail; t = t.next {
-			logicStart := max(off, logicChunkIndex*cw.ChunkSize+t.StartOffset)
-			logicStop := min(off+int64(len(p)), logicChunkIndex*cw.ChunkSize+t.stopOffset)
-			if logicStart < logicStop {
-				actualStart := logicStart - logicChunkIndex*cw.ChunkSize + int64(actualChunkIndex)*cw.ChunkSize
-				_, err := cw.file.ReadAt(p[logicStart-off:logicStop-off], actualStart)
-				if err != nil {
-					glog.Errorf("reading temp file: %v", err)
-					break
-				}
-				maxStop = max(maxStop, logicStop)
-			}
-		}
-	}
-	return
-}
-
-func (cw *ChunkedFileWriter) toActualWriteOffset(logicOffset int64) (actualOffset int64, chunkUsage *ChunkWrittenIntervalList) {
-	logicChunkIndex := LogicChunkIndex(logicOffset / cw.ChunkSize)
-	offsetRemainder := logicOffset % cw.ChunkSize
-	existingActualChunkIndex, found := cw.logicToActualChunkIndex[logicChunkIndex]
-	if found {
-		return int64(existingActualChunkIndex)*cw.ChunkSize + offsetRemainder, cw.chunkUsages[existingActualChunkIndex]
-	}
-	cw.logicToActualChunkIndex[logicChunkIndex] = ActualChunkIndex(len(cw.chunkUsages))
-	chunkUsage = newChunkWrittenIntervalList()
-	cw.chunkUsages = append(cw.chunkUsages, chunkUsage)
-	return int64(len(cw.chunkUsages)-1)*cw.ChunkSize + offsetRemainder, chunkUsage
-}
-
-func (cw *ChunkedFileWriter) toActualReadOffset(logicOffset int64) (actualChunkIndex ActualChunkIndex, chunkUsage *ChunkWrittenIntervalList) {
-	logicChunkIndex := LogicChunkIndex(logicOffset / cw.ChunkSize)
-	existingActualChunkIndex, found := cw.logicToActualChunkIndex[logicChunkIndex]
-	if found {
-		return existingActualChunkIndex, cw.chunkUsages[existingActualChunkIndex]
-	}
-	return 0, nil
-}
-
-func (cw *ChunkedFileWriter) ProcessEachInterval(process func(file *os.File, logicChunkIndex LogicChunkIndex, interval *ChunkWrittenInterval)) {
-	for logicChunkIndex, actualChunkIndex := range cw.logicToActualChunkIndex {
-		chunkUsage := cw.chunkUsages[actualChunkIndex]
-		for t := chunkUsage.head.next; t != chunkUsage.tail; t = t.next {
-			process(cw.file, logicChunkIndex, t)
-		}
-	}
-}
-
-// Reset releases used resources
-func (cw *ChunkedFileWriter) Reset() {
-	if cw.file != nil {
-		cw.file.Close()
-		os.Remove(cw.file.Name())
-		cw.file = nil
-	}
-	cw.logicToActualChunkIndex = make(map[LogicChunkIndex]ActualChunkIndex)
-	cw.chunkUsages = cw.chunkUsages[:0]
-}
-
-type FileIntervalReader struct {
-	f           *os.File
-	startOffset int64
-	stopOffset  int64
-	position    int64
-}
-
-var _ = io.Reader(&FileIntervalReader{})
-
-func NewFileIntervalReader(cw *ChunkedFileWriter, logicChunkIndex LogicChunkIndex, interval *ChunkWrittenInterval) *FileIntervalReader {
-	actualChunkIndex, found := cw.logicToActualChunkIndex[logicChunkIndex]
-	if !found {
-		// this should never happen
-		return nil
-	}
-	return &FileIntervalReader{
-		f:           cw.file,
-		startOffset: int64(actualChunkIndex)*cw.ChunkSize + interval.StartOffset,
-		stopOffset:  int64(actualChunkIndex)*cw.ChunkSize + interval.stopOffset,
-		position:    0,
-	}
-}
-
-func (fr *FileIntervalReader) Read(p []byte) (n int, err error) {
-	readSize := minInt(len(p), int(fr.stopOffset-fr.startOffset-fr.position))
-	n, err = fr.f.ReadAt(p[:readSize], fr.startOffset+fr.position)
-	if err == nil || err == io.EOF {
-		fr.position += int64(n)
-		if fr.stopOffset-fr.startOffset-fr.position == 0 {
-			// return a tiny bit faster
-			err = io.EOF
-			return
-		}
-	}
-	return
-}
@@ -1,60 +0,0 @@
-package page_writer
-
-import (
-	"github.com/stretchr/testify/assert"
-	"os"
-	"testing"
-)
-
-func TestChunkedFileWriter_toActualOffset(t *testing.T) {
-	cw := NewChunkedFileWriter("", 16)
-
-	writeToFile(cw, 50, 60)
-	writeToFile(cw, 60, 64)
-
-	writeToFile(cw, 32, 40)
-	writeToFile(cw, 42, 48)
-
-	writeToFile(cw, 48, 50)
-
-	assert.Equal(t, 1, cw.chunkUsages[0].size(), "fully covered")
-	assert.Equal(t, 2, cw.chunkUsages[1].size(), "2 intervals")
-
-}
-
-func writeToFile(cw *ChunkedFileWriter, startOffset int64, stopOffset int64) {
-
-	_, chunkUsage := cw.toActualWriteOffset(startOffset)
-
-	// skip doing actual writing
-
-	innerOffset := startOffset % cw.ChunkSize
-	chunkUsage.MarkWritten(innerOffset, innerOffset+stopOffset-startOffset)
-
-}
-
-func TestWriteChunkedFile(t *testing.T) {
-	x := NewChunkedFileWriter(os.TempDir(), 20)
-	defer x.Reset()
-	y := NewChunkedFileWriter(os.TempDir(), 12)
-	defer y.Reset()
-
-	batchSize := 4
-	buf := make([]byte, batchSize)
-	for i := 0; i < 256; i++ {
-		for x := 0; x < batchSize; x++ {
-			buf[x] = byte(i)
-		}
-		x.WriteAt(buf, int64(i*batchSize))
-		y.WriteAt(buf, int64((255-i)*batchSize))
-	}
-
-	a := make([]byte, 1)
-	b := make([]byte, 1)
-	for i := 0; i < 256*batchSize; i++ {
-		x.ReadDataAt(a, int64(i))
-		y.ReadDataAt(b, int64(256*batchSize-1-i))
-		assert.Equal(t, a[0], b[0], "same read")
-	}
-
-}
@@ -1,12 +0,0 @@
-package page_writer
-
-import (
-	"io"
-)
-
-type SaveToStorageFunc func(reader io.Reader, offset int64, size int64, cleanupFn func())
-
-type MemChunk struct {
-	buf   []byte
-	usage *ChunkWrittenIntervalList
-}
@@ -1,256 +0,0 @@
-package page_writer
-
-import (
-	"fmt"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/util"
-	"github.com/chrislusf/seaweedfs/weed/util/mem"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-type LogicChunkIndex int
-
-type UploadPipeline struct {
-	filepath             util.FullPath
-	ChunkSize            int64
-	writers              *util.LimitedConcurrentExecutor
-	writableChunks       map[LogicChunkIndex]*MemChunk
-	writableChunksLock   sync.Mutex
-	sealedChunks         map[LogicChunkIndex]*SealedChunk
-	sealedChunksLock     sync.Mutex
-	activeWriterCond     *sync.Cond
-	activeWriterCount    int32
-	activeReadChunks     map[LogicChunkIndex]int
-	activeReadChunksLock sync.Mutex
-	saveToStorageFn      SaveToStorageFunc
-}
-
-type SealedChunk struct {
-	chunk            *MemChunk
-	referenceCounter int // track uploading or reading processes
-}
-
-func (sc *SealedChunk) FreeReference(messageOnFree string) {
-	sc.referenceCounter--
-	if sc.referenceCounter == 0 {
-		glog.V(4).Infof("Free sealed chunk: %s", messageOnFree)
-		mem.Free(sc.chunk.buf)
-	}
-}
-
-func NewUploadPipeline(filepath util.FullPath, writers *util.LimitedConcurrentExecutor, chunkSize int64, saveToStorageFn SaveToStorageFunc) *UploadPipeline {
-	return &UploadPipeline{
-		ChunkSize:        chunkSize,
-		writableChunks:   make(map[LogicChunkIndex]*MemChunk),
-		sealedChunks:     make(map[LogicChunkIndex]*SealedChunk),
-		writers:          writers,
-		activeWriterCond: sync.NewCond(&sync.Mutex{}),
-		saveToStorageFn:  saveToStorageFn,
-		filepath:         filepath,
-		activeReadChunks: make(map[LogicChunkIndex]int),
-	}
-}
-
-func (cw *UploadPipeline) SaveDataAt(p []byte, off int64) (n int) {
-	cw.writableChunksLock.Lock()
-	defer cw.writableChunksLock.Unlock()
-
-	logicChunkIndex := LogicChunkIndex(off / cw.ChunkSize)
-	offsetRemainder := off % cw.ChunkSize
-
-	memChunk, found := cw.writableChunks[logicChunkIndex]
-	if !found {
-		memChunk = &MemChunk{
-			buf:   mem.Allocate(int(cw.ChunkSize)),
-			usage: newChunkWrittenIntervalList(),
-		}
-		cw.writableChunks[logicChunkIndex] = memChunk
-	}
-	n = copy(memChunk.buf[offsetRemainder:], p)
-	memChunk.usage.MarkWritten(offsetRemainder, offsetRemainder+int64(n))
-	cw.maybeMoveToSealed(memChunk, logicChunkIndex)
-
-	return
-}
-
-func (cw *UploadPipeline) MaybeReadDataAt(p []byte, off int64) (maxStop int64) {
-	logicChunkIndex := LogicChunkIndex(off / cw.ChunkSize)
-
-	// read from sealed chunks first
-	cw.sealedChunksLock.Lock()
-	sealedChunk, found := cw.sealedChunks[logicChunkIndex]
-	if found {
-		sealedChunk.referenceCounter++
-	}
-	cw.sealedChunksLock.Unlock()
-	if found {
-		maxStop = readMemChunk(sealedChunk.chunk, p, off, logicChunkIndex, cw.ChunkSize)
-		glog.V(4).Infof("%s read sealed memchunk [%d,%d)", cw.filepath, off, maxStop)
-		sealedChunk.FreeReference(fmt.Sprintf("%s finish reading chunk %d", cw.filepath, logicChunkIndex))
-	}
-
-	// read from writable chunks last
-	cw.writableChunksLock.Lock()
-	defer cw.writableChunksLock.Unlock()
-	writableChunk, found := cw.writableChunks[logicChunkIndex]
-	if !found {
-		return
-	}
-	writableMaxStop := readMemChunk(writableChunk, p, off, logicChunkIndex, cw.ChunkSize)
-	glog.V(4).Infof("%s read writable memchunk [%d,%d)", cw.filepath, off, writableMaxStop)
-	maxStop = max(maxStop, writableMaxStop)
-
-	return
-}
-
-func (cw *UploadPipeline) FlushAll() {
-	cw.writableChunksLock.Lock()
-	defer cw.writableChunksLock.Unlock()
-
-	for logicChunkIndex, memChunk := range cw.writableChunks {
-		cw.moveToSealed(memChunk, logicChunkIndex)
-	}
-
-	cw.waitForCurrentWritersToComplete()
-}
-
-func (cw *UploadPipeline) LockForRead(startOffset, stopOffset int64) {
-	startLogicChunkIndex := LogicChunkIndex(startOffset / cw.ChunkSize)
-	stopLogicChunkIndex := LogicChunkIndex(stopOffset / cw.ChunkSize)
-	if stopOffset%cw.ChunkSize > 0 {
-		stopLogicChunkIndex += 1
-	}
-	cw.activeReadChunksLock.Lock()
-	defer cw.activeReadChunksLock.Unlock()
-	for i := startLogicChunkIndex; i < stopLogicChunkIndex; i++ {
-		if count, found := cw.activeReadChunks[i]; found {
-			cw.activeReadChunks[i] = count + 1
-		} else {
-			cw.activeReadChunks[i] = 1
-		}
-	}
-}
-
-func (cw *UploadPipeline) UnlockForRead(startOffset, stopOffset int64) {
-	startLogicChunkIndex := LogicChunkIndex(startOffset / cw.ChunkSize)
-	stopLogicChunkIndex := LogicChunkIndex(stopOffset / cw.ChunkSize)
-	if stopOffset%cw.ChunkSize > 0 {
-		stopLogicChunkIndex += 1
-	}
-	cw.activeReadChunksLock.Lock()
-	defer cw.activeReadChunksLock.Unlock()
-	for i := startLogicChunkIndex; i < stopLogicChunkIndex; i++ {
-		if count, found := cw.activeReadChunks[i]; found {
-			if count == 1 {
-				delete(cw.activeReadChunks, i)
-			} else {
-				cw.activeReadChunks[i] = count - 1
-			}
-		}
-	}
-}
-
-func (cw *UploadPipeline) IsLocked(logicChunkIndex LogicChunkIndex) bool {
-	cw.activeReadChunksLock.Lock()
-	defer cw.activeReadChunksLock.Unlock()
-	if count, found := cw.activeReadChunks[logicChunkIndex]; found {
-		return count > 0
-	}
-	return false
-}
-
-func (cw *UploadPipeline) waitForCurrentWritersToComplete() {
-	cw.activeWriterCond.L.Lock()
-	t := int32(100)
-	for {
-		t = atomic.LoadInt32(&cw.activeWriterCount)
-		if t <= 0 {
-			break
-		}
-		glog.V(4).Infof("activeWriterCond is %d", t)
-		cw.activeWriterCond.Wait()
-	}
-	cw.activeWriterCond.L.Unlock()
-}
-
-func (cw *UploadPipeline) maybeMoveToSealed(memChunk *MemChunk, logicChunkIndex LogicChunkIndex) {
-	if memChunk.usage.IsComplete(cw.ChunkSize) {
-		cw.moveToSealed(memChunk, logicChunkIndex)
-	}
-}
-
-func (cw *UploadPipeline) moveToSealed(memChunk *MemChunk, logicChunkIndex LogicChunkIndex) {
-	atomic.AddInt32(&cw.activeWriterCount, 1)
-	glog.V(4).Infof("%s activeWriterCount %d ++> %d", cw.filepath, cw.activeWriterCount-1, cw.activeWriterCount)
-
-	cw.sealedChunksLock.Lock()
-
-	if oldMemChunk, found := cw.sealedChunks[logicChunkIndex]; found {
-		oldMemChunk.FreeReference(fmt.Sprintf("%s replace chunk %d", cw.filepath, logicChunkIndex))
-	}
-	sealedChunk := &SealedChunk{
-		chunk:            memChunk,
-		referenceCounter: 1, // default 1 is for uploading process
-	}
-	cw.sealedChunks[logicChunkIndex] = sealedChunk
-	delete(cw.writableChunks, logicChunkIndex)
-
-	cw.sealedChunksLock.Unlock()
-
-	cw.writers.Execute(func() {
-		// first add to the file chunks
-		cw.saveOneChunk(sealedChunk.chunk, logicChunkIndex)
-
-		// notify waiting process
-		atomic.AddInt32(&cw.activeWriterCount, -1)
-		glog.V(4).Infof("%s activeWriterCount %d --> %d", cw.filepath, cw.activeWriterCount+1, cw.activeWriterCount)
-		// Lock and Unlock are not required,
-		// but it may signal multiple times during one wakeup,
-		// and the waiting goroutine may miss some of them!
-		cw.activeWriterCond.L.Lock()
-		cw.activeWriterCond.Broadcast()
-		cw.activeWriterCond.L.Unlock()
-
-		// wait for readers
-		for cw.IsLocked(logicChunkIndex) {
-			time.Sleep(59 * time.Millisecond)
-		}
-
-		// then remove from sealed chunks
-		cw.sealedChunksLock.Lock()
-		defer cw.sealedChunksLock.Unlock()
-		delete(cw.sealedChunks, logicChunkIndex)
-		sealedChunk.FreeReference(fmt.Sprintf("%s finished uploading chunk %d", cw.filepath, logicChunkIndex))
-
-	})
-}
-
-func (cw *UploadPipeline) saveOneChunk(memChunk *MemChunk, logicChunkIndex LogicChunkIndex) {
-	if cw.saveToStorageFn == nil {
-		return
-	}
-	for t := memChunk.usage.head.next; t != memChunk.usage.tail; t = t.next {
-		reader := util.NewBytesReader(memChunk.buf[t.StartOffset:t.stopOffset])
-		cw.saveToStorageFn(reader, int64(logicChunkIndex)*cw.ChunkSize+t.StartOffset, t.Size(), func() {
-		})
-	}
-}
-
-func readMemChunk(memChunk *MemChunk, p []byte, off int64, logicChunkIndex LogicChunkIndex, chunkSize int64) (maxStop int64) {
-	memChunkBaseOffset := int64(logicChunkIndex) * chunkSize
-	for t := memChunk.usage.head.next; t != memChunk.usage.tail; t = t.next {
-		logicStart := max(off, int64(logicChunkIndex)*chunkSize+t.StartOffset)
-		logicStop := min(off+int64(len(p)), memChunkBaseOffset+t.stopOffset)
-		if logicStart < logicStop {
-			copy(p[logicStart-off:logicStop-off], memChunk.buf[logicStart-memChunkBaseOffset:logicStop-memChunkBaseOffset])
-			maxStop = max(maxStop, logicStop)
-		}
-	}
-	return
-}
-
-func (p2 *UploadPipeline) Shutdown() {
-
-}
@@ -1,44 +0,0 @@
-package filesys
-
-type WriterPattern struct {
-	isStreaming     bool
-	lastWriteOffset int64
-	chunkSize       int64
-}
-
-// For streaming write: only cache the first chunk
-// For random write: fall back to temp file approach
-// writes can only change from streaming mode to non-streaming mode
-
-func NewWriterPattern(chunkSize int64) *WriterPattern {
-	return &WriterPattern{
-		isStreaming:     true,
-		lastWriteOffset: -1,
-		chunkSize:       chunkSize,
-	}
-}
-
-func (rp *WriterPattern) MonitorWriteAt(offset int64, size int) {
-	if rp.lastWriteOffset > offset {
-		rp.isStreaming = false
-	}
-	if rp.lastWriteOffset == -1 {
-		if offset != 0 {
-			rp.isStreaming = false
-		}
-	}
-	rp.lastWriteOffset = offset
-}
-
-func (rp *WriterPattern) IsStreamingMode() bool {
-	return rp.isStreaming
-}
-
-func (rp *WriterPattern) IsRandomMode() bool {
-	return !rp.isStreaming
-}
-
-func (rp *WriterPattern) Reset() {
-	rp.isStreaming = true
-	rp.lastWriteOffset = -1
-}
@@ -1,63 +0,0 @@
-package filesys
-
-import (
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/seaweedfs/fuse"
-)
-
-func checkPermission(entry *filer_pb.Entry, uid, gid uint32, isWrite bool) error {
-	if uid == 0 || gid == 0 {
-		return nil
-	}
-	if entry == nil {
-		return nil
-	}
-	if entry.Attributes == nil {
-		return nil
-	}
-	attr := entry.Attributes
-	if attr.Uid == uid {
-		if isWrite {
-			if attr.FileMode&0200 > 0 {
-				return nil
-			} else {
-				return fuse.EPERM
-			}
-		} else {
-			if attr.FileMode&0400 > 0 {
-				return nil
-			} else {
-				return fuse.EPERM
-			}
-		}
-	} else if attr.Gid == gid {
-		if isWrite {
-			if attr.FileMode&0020 > 0 {
-				return nil
-			} else {
-				return fuse.EPERM
-			}
-		} else {
-			if attr.FileMode&0040 > 0 {
-				return nil
-			} else {
-				return fuse.EPERM
-			}
-		}
-	} else {
-		if isWrite {
-			if attr.FileMode&0002 > 0 {
-				return nil
-			} else {
-				return fuse.EPERM
-			}
-		} else {
-			if attr.FileMode&0004 > 0 {
-				return nil
-			} else {
-				return fuse.EPERM
-			}
-		}
-	}
-
-}
@@ -1,22 +0,0 @@
-package filesys
-
-import (
-	"context"
-
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-)
-
-// https://github.com/bazil/fuse/issues/130
-
-var _ = fs.NodeAccesser(&Dir{})
-
-func (dir *Dir) Access(ctx context.Context, req *fuse.AccessRequest) error {
-	return fuse.ENOSYS
-}
-
-var _ = fs.NodeAccesser(&File{})
-
-func (file *File) Access(ctx context.Context, req *fuse.AccessRequest) error {
-	return fuse.ENOSYS
-}
@@ -1,324 +0,0 @@
-package filesys
-
-import (
-	"context"
-	"fmt"
-	"github.com/chrislusf/seaweedfs/weed/pb"
-	"math"
-	"math/rand"
-	"os"
-	"path"
-	"path/filepath"
-	"sync"
-	"time"
-
-	"github.com/chrislusf/seaweedfs/weed/filer"
-	"github.com/chrislusf/seaweedfs/weed/storage/types"
-	"github.com/chrislusf/seaweedfs/weed/wdclient"
-
-	"google.golang.org/grpc"
-
-	"github.com/chrislusf/seaweedfs/weed/util/grace"
-
-	"github.com/seaweedfs/fuse"
-	"github.com/seaweedfs/fuse/fs"
-
-	"github.com/chrislusf/seaweedfs/weed/filesys/meta_cache"
-	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/chrislusf/seaweedfs/weed/util"
-	"github.com/chrislusf/seaweedfs/weed/util/chunk_cache"
-)
-
-type Option struct {
-	MountDirectory     string
-	FilerAddresses     []pb.ServerAddress
-	filerIndex         int
-	GrpcDialOption     grpc.DialOption
-	FilerMountRootPath string
-	Collection         string
-	Replication        string
-	TtlSec             int32
-	DiskType           types.DiskType
-	ChunkSizeLimit     int64
-	ConcurrentWriters  int
-	CacheDir           string
-	CacheSizeMB        int64
-	DataCenter         string
-	Umask              os.FileMode
-
-	MountUid         uint32
-	MountGid         uint32
-	MountMode        os.FileMode
-	MountCtime       time.Time
-	MountMtime       time.Time
-	MountParentInode uint64
-
-	VolumeServerAccess string // how to access volume servers
-	Cipher             bool   // whether encrypt data on volume server
-	UidGidMapper       *meta_cache.UidGidMapper
-
-	uniqueCacheDir         string
-	uniqueCacheTempPageDir string
-}
-
-var _ = fs.FS(&WFS{})
-var _ = fs.FSStatfser(&WFS{})
-
-type WFS struct {
-	option *Option
-
-	// contains all open handles, protected by handlesLock
-	handlesLock sync.Mutex
-	handles     map[uint64]*FileHandle
-
-	bufPool sync.Pool
-
-	stats statsCache
-
-	root        fs.Node
-	fsNodeCache *FsCache
-
-	chunkCache *chunk_cache.TieredChunkCache
-	metaCache  *meta_cache.MetaCache
-	signature  int32
-
-	// throttle writers
-	concurrentWriters *util.LimitedConcurrentExecutor
-	Server            *fs.Server
-}
-type statsCache struct {
-	filer_pb.StatisticsResponse
-	lastChecked int64 // unix time in seconds
-}
-
-func NewSeaweedFileSystem(option *Option) *WFS {
-	wfs := &WFS{
-		option:  option,
-		handles: make(map[uint64]*FileHandle),
-		bufPool: sync.Pool{
-			New: func() interface{} {
-				return make([]byte, option.ChunkSizeLimit)
-			},
-		},
-		signature: util.RandomInt32(),
-	}
-	wfs.option.filerIndex = rand.Intn(len(option.FilerAddresses))
-	wfs.option.setupUniqueCacheDirectory()
-	if option.CacheSizeMB > 0 {
-		wfs.chunkCache = chunk_cache.NewTieredChunkCache(256, option.getUniqueCacheDir(), option.CacheSizeMB, 1024*1024)
-	}
-
-	wfs.metaCache = meta_cache.NewMetaCache(path.Join(option.getUniqueCacheDir(), "meta"), util.FullPath(option.FilerMountRootPath), option.UidGidMapper, func(filePath util.FullPath, entry *filer_pb.Entry) {
-
-		fsNode := NodeWithId(filePath.AsInode(entry.FileMode()))
-		if err := wfs.Server.InvalidateNodeData(fsNode); err != nil {
-			glog.V(4).Infof("InvalidateNodeData %s : %v", filePath, err)
-		}
-
-		dir, name := filePath.DirAndName()
-		parent := NodeWithId(util.FullPath(dir).AsInode(os.ModeDir))
-		if dir == option.FilerMountRootPath {
-			parent = NodeWithId(1)
-		}
-		if err := wfs.Server.InvalidateEntry(parent, name); err != nil {
-			glog.V(4).Infof("InvalidateEntry %s : %v", filePath, err)
-		}
-	})
-	grace.OnInterrupt(func() {
-		wfs.metaCache.Shutdown()
-	})
-
-	wfs.root = &Dir{name: wfs.option.FilerMountRootPath, wfs: wfs, id: 1}
-	wfs.fsNodeCache = newFsCache(wfs.root)
-
-	if wfs.option.ConcurrentWriters > 0 {
-		wfs.concurrentWriters = util.NewLimitedConcurrentExecutor(wfs.option.ConcurrentWriters)
-	}
-
-	return wfs
-}
-
-func (wfs *WFS) StartBackgroundTasks() {
-	startTime := time.Now()
-	go meta_cache.SubscribeMetaEvents(wfs.metaCache, wfs.signature, wfs, wfs.option.FilerMountRootPath, startTime.UnixNano())
-}
-
-func (wfs *WFS) Root() (fs.Node, error) {
-	return wfs.root, nil
-}
-
-func (wfs *WFS) AcquireHandle(file *File, uid, gid uint32) (fileHandle *FileHandle) {
-
-	fullpath := file.fullpath()
-	glog.V(4).Infof("AcquireHandle %s uid=%d gid=%d", fullpath, uid, gid)
-
-	inodeId := file.Id()
-
-	wfs.handlesLock.Lock()
-	existingHandle, found := wfs.handles[inodeId]
-	if found && existingHandle != nil && existingHandle.f.isOpen > 0 {
-		existingHandle.f.isOpen++
-		wfs.handlesLock.Unlock()
-		glog.V(4).Infof("Reuse AcquiredHandle %s open %d", fullpath, existingHandle.f.isOpen)
-		return existingHandle
-	}
-	wfs.handlesLock.Unlock()
-
-	entry, _ := file.maybeLoadEntry(context.Background())
-	file.entry = entry
-	fileHandle = newFileHandle(file, uid, gid)
-
-	wfs.handlesLock.Lock()
-	file.isOpen++
-	wfs.handles[inodeId] = fileHandle
-	wfs.handlesLock.Unlock()
-	fileHandle.handle = inodeId
-
-	glog.V(4).Infof("Acquired new Handle %s open %d", fullpath, file.isOpen)
-	return
-}
-
-func (wfs *WFS) Fsync(file *File, header fuse.Header) error {
-
-	inodeId := file.Id()
-
-	wfs.handlesLock.Lock()
-	existingHandle, found := wfs.handles[inodeId]
-	wfs.handlesLock.Unlock()
-
-	if found && existingHandle != nil {
-
-		existingHandle.Lock()
-		defer existingHandle.Unlock()
-
-		if existingHandle.f.isOpen > 0 {
-			return existingHandle.doFlush(context.Background(), header)
-		}
-
-	}
-
-	return nil
-}
-
-func (wfs *WFS) ReleaseHandle(fullpath util.FullPath, handleId fuse.HandleID) {
-	wfs.handlesLock.Lock()
-	defer wfs.handlesLock.Unlock()
-
-	glog.V(4).Infof("ReleaseHandle %s id %d current handles length %d", fullpath, handleId, len(wfs.handles))
-
-	delete(wfs.handles, uint64(handleId))
-
-	return
-}
-
-// Statfs is called to obtain file system metadata. Implements fuse.FSStatfser
-func (wfs *WFS) Statfs(ctx context.Context, req *fuse.StatfsRequest, resp *fuse.StatfsResponse) error {
-
-	glog.V(4).Infof("reading fs stats: %+v", req)
-
-	if wfs.stats.lastChecked < time.Now().Unix()-20 {
-
-		err := wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
-
-			request := &filer_pb.StatisticsRequest{
-				Collection:  wfs.option.Collection,
-				Replication: wfs.option.Replication,
-				Ttl:         fmt.Sprintf("%ds", wfs.option.TtlSec),
-				DiskType:    string(wfs.option.DiskType),
-			}
-
-			glog.V(4).Infof("reading filer stats: %+v", request)
-			resp, err := client.Statistics(context.Background(), request)
-			if err != nil {
-				glog.V(0).Infof("reading filer stats %v: %v", request, err)
-				return err
-			}
-			glog.V(4).Infof("read filer stats: %+v", resp)
-
-			wfs.stats.TotalSize = resp.TotalSize
-			wfs.stats.UsedSize = resp.UsedSize
-			wfs.stats.FileCount = resp.FileCount
-			wfs.stats.lastChecked = time.Now().Unix()
-
-			return nil
-		})
-		if err != nil {
-			glog.V(0).Infof("filer Statistics: %v", err)
-			return err
-		}
-	}
-
-	totalDiskSize := wfs.stats.TotalSize
-	usedDiskSize := wfs.stats.UsedSize
-	actualFileCount := wfs.stats.FileCount
-
-	// Compute the total number of available blocks
-	resp.Blocks = totalDiskSize / blockSize
-
-	// Compute the number of used blocks
-	numBlocks := uint64(usedDiskSize / blockSize)
-
-	// Report the number of free and available blocks for the block size
-	resp.Bfree = resp.Blocks - numBlocks
-	resp.Bavail = resp.Blocks - numBlocks
-	resp.Bsize = uint32(blockSize)
-
-	// Report the total number of possible files in the file system (and those free)
-	resp.Files = math.MaxInt64
-	resp.Ffree = math.MaxInt64 - actualFileCount
-
-	// Report the maximum length of a name and the minimum fragment size
-	resp.Namelen = 1024
-	resp.Frsize = uint32(blockSize)
-
-	return nil
-}
-
-func (wfs *WFS) mapPbIdFromFilerToLocal(entry *filer_pb.Entry) {
-	if entry.Attributes == nil {
-		return
-	}
-	entry.Attributes.Uid, entry.Attributes.Gid = wfs.option.UidGidMapper.FilerToLocal(entry.Attributes.Uid, entry.Attributes.Gid)
-}
-func (wfs *WFS) mapPbIdFromLocalToFiler(entry *filer_pb.Entry) {
-	if entry.Attributes == nil {
-		return
-	}
-	entry.Attributes.Uid, entry.Attributes.Gid = wfs.option.UidGidMapper.LocalToFiler(entry.Attributes.Uid, entry.Attributes.Gid)
-}
-
-func (wfs *WFS) LookupFn() wdclient.LookupFileIdFunctionType {
-	if wfs.option.VolumeServerAccess == "filerProxy" {
-		return func(fileId string) (targetUrls []string, err error) {
-			return []string{"http://" + wfs.getCurrentFiler().ToHttpAddress() + "/?proxyChunkId=" + fileId}, nil
-		}
-	}
-	return filer.LookupFn(wfs)
-}
-func (wfs *WFS) getCurrentFiler() pb.ServerAddress {
-	return wfs.option.FilerAddresses[wfs.option.filerIndex]
-}
-
-func (option *Option) setupUniqueCacheDirectory() {
-	cacheUniqueId := util.Md5String([]byte(option.MountDirectory + string(option.FilerAddresses[0]) + option.FilerMountRootPath + util.Version()))[0:8]
-	option.uniqueCacheDir = path.Join(option.CacheDir, cacheUniqueId)
-	option.uniqueCacheTempPageDir = filepath.Join(option.uniqueCacheDir, "sw")
-	os.MkdirAll(option.uniqueCacheTempPageDir, os.FileMode(0777)&^option.Umask)
-}
-
-func (option *Option) getTempFilePageDir() string {
-	return option.uniqueCacheTempPageDir
-}
-func (option *Option) getUniqueCacheDir() string {
-	return option.uniqueCacheDir
-}
-
-type NodeWithId uint64
-
-func (n NodeWithId) Id() uint64 {
-	return uint64(n)
-}
-func (n NodeWithId) Attr(ctx context.Context, attr *fuse.Attr) error {
-	return nil
-}
@@ -1,153 +0,0 @@
-package filesys
-
-import (
-	"context"
-	"strings"
-	"syscall"
-
-	"github.com/seaweedfs/fuse"
-
-	"github.com/chrislusf/seaweedfs/weed/filesys/meta_cache"
-	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
-	"github.com/chrislusf/seaweedfs/weed/util"
-)
-
-const (
-	XATTR_PREFIX = "xattr-" // same as filer
-)
-
-func getxattr(entry *filer_pb.Entry, req *fuse.GetxattrRequest, resp *fuse.GetxattrResponse) error {
-
-	if entry == nil {
-		return fuse.ErrNoXattr
-	}
-	if entry.Extended == nil {
-		return fuse.ErrNoXattr
-	}
-	data, found := entry.Extended[XATTR_PREFIX+req.Name]
-	if !found {
-		return fuse.ErrNoXattr
-	}
-	if req.Position < uint32(len(data)) {
-		size := req.Size
-		if req.Position+size >= uint32(len(data)) {
-			size = uint32(len(data)) - req.Position
-		}
-		if size == 0 {
-			resp.Xattr = data[req.Position:]
-		} else {
-			resp.Xattr = data[req.Position : req.Position+size]
-		}
-	}
-
-	return nil
-
-}
-
-func setxattr(entry *filer_pb.Entry, req *fuse.SetxattrRequest) error {
-
-	if entry == nil {
-		return fuse.EIO
-	}
-
-	if entry.Extended == nil {
-		entry.Extended = make(map[string][]byte)
-	}
-	data, _ := entry.Extended[XATTR_PREFIX+req.Name]
-
-	newData := make([]byte, int(req.Position)+len(req.Xattr))
-
-	copy(newData, data)
-
-	copy(newData[int(req.Position):], req.Xattr)
-
-	entry.Extended[XATTR_PREFIX+req.Name] = newData
-
-	return nil
-
-}
-
-func removexattr(entry *filer_pb.Entry, req *fuse.RemovexattrRequest) error {
-
-	if entry == nil {
-		return fuse.ErrNoXattr
-	}
-
-	if entry.Extended == nil {
-		return fuse.ErrNoXattr
-	}
-
-	_, found := entry.Extended[XATTR_PREFIX+req.Name]
-
-	if !found {
-		return fuse.ErrNoXattr
-	}
-
-	delete(entry.Extended, XATTR_PREFIX+req.Name)
-
-	return nil
-
-}
-
-func listxattr(entry *filer_pb.Entry, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
-
-	if entry == nil {
-		return fuse.EIO
-	}
-
-	for k := range entry.Extended {
-		if strings.HasPrefix(k, XATTR_PREFIX) {
-			resp.Append(k[len(XATTR_PREFIX):])
-		}
-	}
-
-	size := req.Size
-	if req.Position+size >= uint32(len(resp.Xattr)) {
-		size = uint32(len(resp.Xattr)) - req.Position
-	}
-
-	if size == 0 {
-		resp.Xattr = resp.Xattr[req.Position:]
-	} else {
-		resp.Xattr = resp.Xattr[req.Position : req.Position+size]
-	}
-
-	return nil
-
-}
-
-func (wfs *WFS) maybeLoadEntry(dir, name string) (entry *filer_pb.Entry, err error) {
-
-	fullpath := util.NewFullPath(dir, name)
-	// glog.V(3).Infof("read entry cache miss %s", fullpath)
-
-	// return a valid entry for the mount root
-	if string(fullpath) == wfs.option.FilerMountRootPath {
-		return &filer_pb.Entry{
-			Name:        name,
-			IsDirectory: true,
-			Attributes: &filer_pb.FuseAttributes{
-				Mtime:    wfs.option.MountMtime.Unix(),
-				FileMode: uint32(wfs.option.MountMode),
-				Uid:      wfs.option.MountUid,
-				Gid:      wfs.option.MountGid,
-				Crtime:   wfs.option.MountCtime.Unix(),
-			},
-		}, nil
-	}
-
-	// read from async meta cache
-	meta_cache.EnsureVisited(wfs.metaCache, wfs, util.FullPath(dir))
-	cachedEntry, cacheErr := wfs.metaCache.FindEntry(context.Background(), fullpath)
-	if cacheErr == filer_pb.ErrNotFound {
-		return nil, fuse.ENOENT
-	}
-	return cachedEntry.ToProtoEntry(), cacheErr
-}
-
-func checkName(name string) error {
-	if len(name) >= 256 {
-		return syscall.ENAMETOOLONG
-	}
-	return nil
-}
@@ -1,6 +1,7 @@
 package images

 import (
+	"github.com/chrislusf/seaweedfs/weed/util"
 	"os"
 	"testing"
 )
@@ -12,7 +13,7 @@ func TestXYZ(t *testing.T) {

 	fixed_data := FixJpgOrientation(dat)

-	os.WriteFile("fixed1.jpg", fixed_data, 0644)
+	util.WriteFile("fixed1.jpg", fixed_data, 0644)

 	os.Remove("fixed1.jpg")

@@ -2,6 +2,7 @@ package images

 import (
 	"bytes"
+	"github.com/chrislusf/seaweedfs/weed/util"
 	"os"
 	"testing"
 )
@@ -15,7 +16,7 @@ func TestResizing(t *testing.T) {
 	buf := new(bytes.Buffer)
 	buf.ReadFrom(resized)

-	os.WriteFile("resized1.png", buf.Bytes(), 0644)
+	util.WriteFile("resized1.png", buf.Bytes(), 0644)

 	os.Remove("resized1.png")

@@ -0,0 +1,99 @@
+package mount
+
+import (
+	"fmt"
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/mount/page_writer"
+	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
+	"io"
+	"sync"
+	"time"
+)
+
+type ChunkedDirtyPages struct {
+	fh             *FileHandle
+	writeWaitGroup sync.WaitGroup
+	lastErr        error
+	collection     string
+	replication    string
+	uploadPipeline *page_writer.UploadPipeline
+	hasWrites      bool
+}
+
+var (
+	_ = page_writer.DirtyPages(&ChunkedDirtyPages{})
+)
+
+func newMemoryChunkPages(fh *FileHandle, chunkSize int64) *ChunkedDirtyPages {
+
+	dirtyPages := &ChunkedDirtyPages{
+		fh: fh,
+	}
+
+	dirtyPages.uploadPipeline = page_writer.NewUploadPipeline(fh.wfs.concurrentWriters, chunkSize, dirtyPages.saveChunkedFileIntevalToStorage, fh.wfs.option.ConcurrentWriters)
+
+	return dirtyPages
+}
+
+func (pages *ChunkedDirtyPages) AddPage(offset int64, data []byte) {
+	pages.hasWrites = true
+
+	glog.V(4).Infof("%v memory AddPage [%d, %d)", pages.fh.fh, offset, offset+int64(len(data)))
+	pages.uploadPipeline.SaveDataAt(data, offset)
+
+	return
+}
+
+func (pages *ChunkedDirtyPages) FlushData() error {
+	if !pages.hasWrites {
+		return nil
+	}
+	pages.uploadPipeline.FlushAll()
+	if pages.lastErr != nil {
+		return fmt.Errorf("flush data: %v", pages.lastErr)
+	}
+	return nil
+}
+
+func (pages *ChunkedDirtyPages) ReadDirtyDataAt(data []byte, startOffset int64) (maxStop int64) {
+	if !pages.hasWrites {
+		return
+	}
+	return pages.uploadPipeline.MaybeReadDataAt(data, startOffset)
+}
+
+func (pages *ChunkedDirtyPages) GetStorageOptions() (collection, replication string) {
+	return pages.collection, pages.replication
+}
+
+func (pages *ChunkedDirtyPages) saveChunkedFileIntevalToStorage(reader io.Reader, offset int64, size int64, cleanupFn func()) {
+
+	mtime := time.Now().UnixNano()
+	defer cleanupFn()
+
+	fileFullPath := pages.fh.FullPath()
+	fileName := fileFullPath.Name()
+	chunk, collection, replication, err := pages.fh.wfs.saveDataAsChunk(fileFullPath)(reader, fileName, offset)
+	if err != nil {
+		glog.V(0).Infof("%v saveToStorage [%d,%d): %v", fileFullPath, offset, offset+size, err)
+		pages.lastErr = err
+		return
+	}
+	chunk.Mtime = mtime
+	pages.collection, pages.replication = collection, replication
+	pages.fh.addChunks([]*filer_pb.FileChunk{chunk})
+	pages.fh.entryViewCache = nil
+	glog.V(3).Infof("%v saveToStorage %s [%d,%d)", fileFullPath, chunk.FileId, offset, offset+size)
+
+}
+
+func (pages ChunkedDirtyPages) Destroy() {
+	pages.uploadPipeline.Shutdown()
+}
+
+func (pages *ChunkedDirtyPages) LockForRead(startOffset, stopOffset int64) {
+	pages.uploadPipeline.LockForRead(startOffset, stopOffset)
+}
+func (pages *ChunkedDirtyPages) UnlockForRead(startOffset, stopOffset int64) {
+	pages.uploadPipeline.UnlockForRead(startOffset, stopOffset)
+}
@@ -0,0 +1,96 @@
+package mount
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
+	"github.com/chrislusf/seaweedfs/weed/util"
+	"io"
+	"sort"
+	"sync"
+)
+
+type FileHandleId uint64
+
+type FileHandle struct {
+	fh           FileHandleId
+	counter      int64
+	entry        *filer_pb.Entry
+	chunkAddLock sync.Mutex
+	inode        uint64
+	wfs          *WFS
+
+	// cache file has been written to
+	dirtyMetadata  bool
+	dirtyPages     *PageWriter
+	entryViewCache []filer.VisibleInterval
+	reader         io.ReaderAt
+	contentType    string
+	handle         uint64
+	sync.Mutex
+
+	isDeleted bool
+}
+
+func newFileHandle(wfs *WFS, handleId FileHandleId, inode uint64, entry *filer_pb.Entry) *FileHandle {
+	fh := &FileHandle{
+		fh:      handleId,
+		counter: 1,
+		inode:   inode,
+		wfs:     wfs,
+	}
+	// dirtyPages: newContinuousDirtyPages(file, writeOnly),
+	fh.dirtyPages = newPageWriter(fh, wfs.option.ChunkSizeLimit)
+	if entry != nil {
+		entry.Attributes.FileSize = filer.FileSize(entry)
+	}
+
+	return fh
+}
+
+func (fh *FileHandle) FullPath() util.FullPath {
+	fp, _ := fh.wfs.inodeToPath.GetPath(fh.inode)
+	return fp
+}
+
+func (fh *FileHandle) addChunks(chunks []*filer_pb.FileChunk) {
+
+	// find the earliest incoming chunk
+	newChunks := chunks
+	earliestChunk := newChunks[0]
+	for i := 1; i < len(newChunks); i++ {
+		if lessThan(earliestChunk, newChunks[i]) {
+			earliestChunk = newChunks[i]
+		}
+	}
+
+	if fh.entry == nil {
+		return
+	}
+
+	// pick out-of-order chunks from existing chunks
+	for _, chunk := range fh.entry.Chunks {
+		if lessThan(earliestChunk, chunk) {
+			chunks = append(chunks, chunk)
+		}
+	}
+
+	// sort incoming chunks
+	sort.Slice(chunks, func(i, j int) bool {
+		return lessThan(chunks[i], chunks[j])
+	})
+
+	glog.V(4).Infof("%s existing %d chunks adds %d more", fh.FullPath(), len(fh.entry.Chunks), len(chunks))
+
+	fh.chunkAddLock.Lock()
+	fh.entry.Chunks = append(fh.entry.Chunks, newChunks...)
+	fh.entryViewCache = nil
+	fh.chunkAddLock.Unlock()
+}
+
+func lessThan(a, b *filer_pb.FileChunk) bool {
+	if a.Mtime == b.Mtime {
+		return a.Fid.FileKey < b.Fid.FileKey
+	}
+	return a.Mtime < b.Mtime
+}
@@ -0,0 +1,84 @@
+package mount
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
+	"sync"
+)
+
+type FileHandleToInode struct {
+	sync.RWMutex
+	nextFh   FileHandleId
+	inode2fh map[uint64]*FileHandle
+	fh2inode map[FileHandleId]uint64
+}
+
+func NewFileHandleToInode() *FileHandleToInode {
+	return &FileHandleToInode{
+		inode2fh: make(map[uint64]*FileHandle),
+		fh2inode: make(map[FileHandleId]uint64),
+		nextFh:   0,
+	}
+}
+
+func (i *FileHandleToInode) GetFileHandle(fh FileHandleId) *FileHandle {
+	i.RLock()
+	defer i.RUnlock()
+	inode, found := i.fh2inode[fh]
+	if found {
+		return i.inode2fh[inode]
+	}
+	return nil
+}
+
+func (i *FileHandleToInode) FindFileHandle(inode uint64) (fh *FileHandle, found bool) {
+	i.RLock()
+	defer i.RUnlock()
+	fh, found = i.inode2fh[inode]
+	return
+}
+
+func (i *FileHandleToInode) AcquireFileHandle(wfs *WFS, inode uint64, entry *filer_pb.Entry) *FileHandle {
+	i.Lock()
+	defer i.Unlock()
+	fh, found := i.inode2fh[inode]
+	if !found {
+		fh = newFileHandle(wfs, i.nextFh, inode, entry)
+		i.nextFh++
+		i.inode2fh[inode] = fh
+		i.fh2inode[fh.fh] = inode
+	} else {
+		fh.counter++
+	}
+	return fh
+}
+
+func (i *FileHandleToInode) ReleaseByInode(inode uint64) {
+	i.Lock()
+	defer i.Unlock()
+	fh, found := i.inode2fh[inode]
+	if found {
+		fh.counter--
+		if fh.counter <= 0 {
+			delete(i.inode2fh, inode)
+			delete(i.fh2inode, fh.fh)
+		}
+	}
+}
+func (i *FileHandleToInode) ReleaseByHandle(fh FileHandleId) {
+	i.Lock()
+	defer i.Unlock()
+	inode, found := i.fh2inode[fh]
+	if found {
+		fhHandle, fhFound := i.inode2fh[inode]
+		if !fhFound {
+			delete(i.fh2inode, fh)
+		} else {
+			fhHandle.counter--
+			if fhHandle.counter <= 0 {
+				delete(i.inode2fh, inode)
+				delete(i.fh2inode, fhHandle.fh)
+			}
+		}
+
+	}
+}
@@ -0,0 +1,113 @@
+package mount
+
+import (
+	"context"
+	"fmt"
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
+	"io"
+)
+
+func (fh *FileHandle) lockForRead(startOffset int64, size int) {
+	fh.dirtyPages.LockForRead(startOffset, startOffset+int64(size))
+}
+func (fh *FileHandle) unlockForRead(startOffset int64, size int) {
+	fh.dirtyPages.UnlockForRead(startOffset, startOffset+int64(size))
+}
+
+func (fh *FileHandle) readFromDirtyPages(buff []byte, startOffset int64) (maxStop int64) {
+	maxStop = fh.dirtyPages.ReadDirtyDataAt(buff, startOffset)
+	return
+}
+
+func (fh *FileHandle) readFromChunks(buff []byte, offset int64) (int64, error) {
+
+	fileFullPath := fh.FullPath()
+
+	entry := fh.entry
+	if entry == nil {
+		return 0, io.EOF
+	}
+
+	if entry.IsInRemoteOnly() {
+		glog.V(4).Infof("download remote entry %s", fileFullPath)
+		newEntry, err := fh.downloadRemoteEntry(entry)
+		if err != nil {
+			glog.V(1).Infof("download remote entry %s: %v", fileFullPath, err)
+			return 0, err
+		}
+		entry = newEntry
+	}
+
+	fileSize := int64(filer.FileSize(entry))
+
+	if fileSize == 0 {
+		glog.V(1).Infof("empty fh %v", fileFullPath)
+		return 0, io.EOF
+	}
+
+	if offset+int64(len(buff)) <= int64(len(entry.Content)) {
+		totalRead := copy(buff, entry.Content[offset:])
+		glog.V(4).Infof("file handle read cached %s [%d,%d] %d", fileFullPath, offset, offset+int64(totalRead), totalRead)
+		return int64(totalRead), nil
+	}
+
+	var chunkResolveErr error
+	if fh.entryViewCache == nil {
+		fh.entryViewCache, chunkResolveErr = filer.NonOverlappingVisibleIntervals(fh.wfs.LookupFn(), entry.Chunks, 0, fileSize)
+		if chunkResolveErr != nil {
+			return 0, fmt.Errorf("fail to resolve chunk manifest: %v", chunkResolveErr)
+		}
+		fh.reader = nil
+	}
+
+	reader := fh.reader
+	if reader == nil {
+		chunkViews := filer.ViewFromVisibleIntervals(fh.entryViewCache, 0, fileSize)
+		glog.V(4).Infof("file handle read %s [%d,%d) from %d views", fileFullPath, offset, offset+int64(len(buff)), len(chunkViews))
+		for _, chunkView := range chunkViews {
+			glog.V(4).Infof("  read %s [%d,%d) from chunk %+v", fileFullPath, chunkView.LogicOffset, chunkView.LogicOffset+int64(chunkView.Size), chunkView.FileId)
+		}
+		reader = filer.NewChunkReaderAtFromClient(fh.wfs.LookupFn(), chunkViews, fh.wfs.chunkCache, fileSize)
+	}
+	fh.reader = reader
+
+	totalRead, err := reader.ReadAt(buff, offset)
+
+	if err != nil && err != io.EOF {
+		glog.Errorf("file handle read %s: %v", fileFullPath, err)
+	}
+
+	// glog.V(4).Infof("file handle read %s [%d,%d] %d : %v", fileFullPath, offset, offset+int64(totalRead), totalRead, err)
+
+	return int64(totalRead), err
+}
+
+func (fh *FileHandle) downloadRemoteEntry(entry *filer_pb.Entry) (*filer_pb.Entry, error) {
+
+	fileFullPath := fh.FullPath()
+	dir, _ := fileFullPath.DirAndName()
+
+	err := fh.wfs.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
+
+		request := &filer_pb.CacheRemoteObjectToLocalClusterRequest{
+			Directory: string(dir),
+			Name:      entry.Name,
+		}
+
+		glog.V(4).Infof("download entry: %v", request)
+		resp, err := client.CacheRemoteObjectToLocalCluster(context.Background(), request)
+		if err != nil {
+			return fmt.Errorf("CacheRemoteObjectToLocalCluster file %s: %v", fileFullPath, err)
+		}
+
+		entry = resp.Entry
+
+		fh.wfs.metaCache.InsertEntry(context.Background(), filer.FromPbEntry(request.Directory, resp.Entry))
+
+		return nil
+	})
+
+	return entry, err
+}
@@ -0,0 +1,195 @@
+package mount
+
+import (
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/util"
+	"github.com/hanwen/go-fuse/v2/fuse"
+	"os"
+	"sync"
+)
+
+type InodeToPath struct {
+	sync.RWMutex
+	nextInodeId uint64
+	inode2path  map[uint64]*InodeEntry
+	path2inode  map[util.FullPath]uint64
+}
+type InodeEntry struct {
+	util.FullPath
+	nlookup          uint64
+	isDirectory      bool
+	isChildrenCached bool
+}
+
+func NewInodeToPath(root util.FullPath) *InodeToPath {
+	t := &InodeToPath{
+		inode2path: make(map[uint64]*InodeEntry),
+		path2inode: make(map[util.FullPath]uint64),
+	}
+	t.inode2path[1] = &InodeEntry{root, 1, true, false}
+	t.path2inode[root] = 1
+	return t
+}
+
+func (i *InodeToPath) Lookup(path util.FullPath, mode os.FileMode, isHardlink bool, possibleInode uint64, isLookup bool) uint64 {
+	i.Lock()
+	defer i.Unlock()
+	inode, found := i.path2inode[path]
+	if !found {
+		if possibleInode == 0 {
+			inode = path.AsInode(mode)
+		} else {
+			inode = possibleInode
+		}
+		if !isHardlink {
+			for _, found := i.inode2path[inode]; found; inode++ {
+				_, found = i.inode2path[inode]
+			}
+		}
+	}
+	i.path2inode[path] = inode
+
+	if _, found := i.inode2path[inode]; found {
+		if isLookup {
+			i.inode2path[inode].nlookup++
+		}
+	} else {
+		if !isLookup {
+			i.inode2path[inode] = &InodeEntry{path, 0, mode&os.ModeDir > 0, false}
+		} else {
+			i.inode2path[inode] = &InodeEntry{path, 1, mode&os.ModeDir > 0, false}
+		}
+	}
+
+	return inode
+}
+
+func (i *InodeToPath) AllocateInode(path util.FullPath, mode os.FileMode) uint64 {
+	if path == "/" {
+		return 1
+	}
+	i.Lock()
+	defer i.Unlock()
+	inode := path.AsInode(mode)
+	for _, found := i.inode2path[inode]; found; inode++ {
+		_, found = i.inode2path[inode]
+	}
+	return inode
+}
+
+func (i *InodeToPath) GetInode(path util.FullPath) uint64 {
+	if path == "/" {
+		return 1
+	}
+	i.Lock()
+	defer i.Unlock()
+	inode, found := i.path2inode[path]
+	if !found {
+		// glog.Fatalf("GetInode unknown inode for %s", path)
+		// this could be the parent for mount point
+	}
+	return inode
+}
+
+func (i *InodeToPath) GetPath(inode uint64) (util.FullPath, fuse.Status) {
+	i.RLock()
+	defer i.RUnlock()
+	path, found := i.inode2path[inode]
+	if !found {
+		return "", fuse.ENOENT
+	}
+	return path.FullPath, fuse.OK
+}
+
+func (i *InodeToPath) HasPath(path util.FullPath) bool {
+	i.RLock()
+	defer i.RUnlock()
+	_, found := i.path2inode[path]
+	return found
+}
+
+func (i *InodeToPath) MarkChildrenCached(fullpath util.FullPath) {
+	i.RLock()
+	defer i.RUnlock()
+	inode, found := i.path2inode[fullpath]
+	if !found {
+		glog.Fatalf("MarkChildrenCached not found inode %v", fullpath)
+	}
+	path, found := i.inode2path[inode]
+	path.isChildrenCached = true
+}
+
+func (i *InodeToPath) IsChildrenCached(fullpath util.FullPath) bool {
+	i.RLock()
+	defer i.RUnlock()
+	inode, found := i.path2inode[fullpath]
+	if !found {
+		return false
+	}
+	path, found := i.inode2path[inode]
+	if found {
+		return path.isChildrenCached
+	}
+	return false
+}
+
+func (i *InodeToPath) HasInode(inode uint64) bool {
+	if inode == 1 {
+		return true
+	}
+	i.RLock()
+	defer i.RUnlock()
+	_, found := i.inode2path[inode]
+	return found
+}
+
+func (i *InodeToPath) RemovePath(path util.FullPath) {
+	i.Lock()
+	defer i.Unlock()
+	inode, found := i.path2inode[path]
+	if found {
+		delete(i.path2inode, path)
+		delete(i.inode2path, inode)
+	}
+}
+
+func (i *InodeToPath) MovePath(sourcePath, targetPath util.FullPath) (replacedInode uint64) {
+	i.Lock()
+	defer i.Unlock()
+	sourceInode, sourceFound := i.path2inode[sourcePath]
+	targetInode, targetFound := i.path2inode[targetPath]
+	if sourceFound {
+		delete(i.path2inode, sourcePath)
+		i.path2inode[targetPath] = sourceInode
+	} else {
+		// it is possible some source folder items has not been visited before
+		// so no need to worry about their source inodes
+		return
+	}
+	i.inode2path[sourceInode].FullPath = targetPath
+	if targetFound {
+		delete(i.inode2path, targetInode)
+	} else {
+		i.inode2path[sourceInode].nlookup++
+	}
+	return targetInode
+}
+
+func (i *InodeToPath) Forget(inode, nlookup uint64, onForgetDir func(dir util.FullPath)) {
+	i.Lock()
+	path, found := i.inode2path[inode]
+	if found {
+		path.nlookup -= nlookup
+		if path.nlookup <= 0 {
+			delete(i.path2inode, path.FullPath)
+			delete(i.inode2path, inode)
+		}
+	}
+	i.Unlock()
+	if found {
+		if path.isDirectory && path.nlookup <= 0 && onForgetDir != nil {
+			path.isChildrenCached = false
+			onForgetDir(path.FullPath)
+		}
+	}
+}
@@ -7,7 +7,6 @@ import (
 	"github.com/chrislusf/seaweedfs/weed/glog"
 	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
 	"github.com/chrislusf/seaweedfs/weed/util"
-	"github.com/chrislusf/seaweedfs/weed/util/bounded_tree"
 	"os"
 )

@@ -15,18 +14,23 @@ import (
 // e.g. fill fileId field for chunks

 type MetaCache struct {
+	root       util.FullPath
 	localStore filer.VirtualFilerStore
 	// sync.RWMutex
-	visitedBoundary *bounded_tree.BoundedTree
-	uidGidMapper    *UidGidMapper
-	invalidateFunc  func(fullpath util.FullPath, entry *filer_pb.Entry)
+	uidGidMapper   *UidGidMapper
+	markCachedFn   func(fullpath util.FullPath)
+	isCachedFn     func(fullpath util.FullPath) bool
+	invalidateFunc func(fullpath util.FullPath, entry *filer_pb.Entry)
 }

-func NewMetaCache(dbFolder string, baseDir util.FullPath, uidGidMapper *UidGidMapper, invalidateFunc func(util.FullPath, *filer_pb.Entry)) *MetaCache {
+func NewMetaCache(dbFolder string, uidGidMapper *UidGidMapper, root util.FullPath,
+	markCachedFn func(path util.FullPath), isCachedFn func(path util.FullPath) bool, invalidateFunc func(util.FullPath, *filer_pb.Entry)) *MetaCache {
 	return &MetaCache{
-		localStore:      openMetaStore(dbFolder),
-		visitedBoundary: bounded_tree.NewBoundedTree(baseDir),
-		uidGidMapper:    uidGidMapper,
+		root:         root,
+		localStore:   openMetaStore(dbFolder),
+		markCachedFn: markCachedFn,
+		isCachedFn:   isCachedFn,
+		uidGidMapper: uidGidMapper,
 		invalidateFunc: func(fullpath util.FullPath, entry *filer_pb.Entry) {
 			invalidateFunc(fullpath, entry)
 		},
@@ -61,20 +65,26 @@ func (mc *MetaCache) doInsertEntry(ctx context.Context, entry *filer.Entry) erro
 	return mc.localStore.InsertEntry(ctx, entry)
 }

-func (mc *MetaCache) AtomicUpdateEntryFromFiler(ctx context.Context, oldPath util.FullPath, newEntry *filer.Entry) error {
+func (mc *MetaCache) AtomicUpdateEntryFromFiler(ctx context.Context, oldPath util.FullPath, newEntry *filer.Entry, shouldDeleteChunks bool) error {
 	//mc.Lock()
 	//defer mc.Unlock()

 	oldDir, _ := oldPath.DirAndName()
-	if mc.visitedBoundary.HasVisited(util.FullPath(oldDir)) {
+	if mc.isCachedFn(util.FullPath(oldDir)) {
 		if oldPath != "" {
 			if newEntry != nil && oldPath == newEntry.FullPath {
 				// skip the unnecessary deletion
 				// leave the update to the following InsertEntry operation
 			} else {
 				glog.V(3).Infof("DeleteEntry %s", oldPath)
-				if err := mc.localStore.DeleteEntry(ctx, oldPath); err != nil {
-					return err
+				if shouldDeleteChunks {
+					if err := mc.localStore.DeleteEntry(ctx, oldPath); err != nil {
+						return err
+					}
+				} else {
+					if err := mc.localStore.DeleteOneEntrySkipHardlink(ctx, oldPath); err != nil {
+						return err
+					}
 				}
 			}
 		}
@@ -84,7 +94,7 @@ func (mc *MetaCache) AtomicUpdateEntryFromFiler(ctx context.Context, oldPath uti

 	if newEntry != nil {
 		newDir, _ := newEntry.DirAndName()
-		if mc.visitedBoundary.HasVisited(util.FullPath(newDir)) {
+		if mc.isCachedFn(util.FullPath(newDir)) {
 			glog.V(3).Infof("InsertEntry %s/%s", newDir, newEntry.Name())
 			if err := mc.localStore.InsertEntry(ctx, newEntry); err != nil {
 				return err
@@ -111,17 +121,28 @@ func (mc *MetaCache) FindEntry(ctx context.Context, fp util.FullPath) (entry *fi
 	return
 }

+func (mc *MetaCache) DeleteEntrySkipHardlink(ctx context.Context, fp util.FullPath) (err error) {
+	//mc.Lock()
+	//defer mc.Unlock()
+	return mc.localStore.DeleteOneEntrySkipHardlink(ctx, fp)
+}
+
 func (mc *MetaCache) DeleteEntry(ctx context.Context, fp util.FullPath) (err error) {
 	//mc.Lock()
 	//defer mc.Unlock()
 	return mc.localStore.DeleteEntry(ctx, fp)
 }
+func (mc *MetaCache) DeleteFolderChildren(ctx context.Context, fp util.FullPath) (err error) {
+	//mc.Lock()
+	//defer mc.Unlock()
+	return mc.localStore.DeleteFolderChildren(ctx, fp)
+}

 func (mc *MetaCache) ListDirectoryEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, eachEntryFunc filer.ListEachEntryFunc) error {
 	//mc.RLock()
 	//defer mc.RUnlock()

-	if !mc.visitedBoundary.HasVisited(dirPath) {
+	if !mc.isCachedFn(dirPath) {
 		// if this request comes after renaming, it should be fine
 		glog.Warningf("unsynchronized dir: %v", dirPath)
 	}
@@ -0,0 +1,78 @@
+package meta_cache
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/chrislusf/seaweedfs/weed/filer"
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/pb/filer_pb"
+	"github.com/chrislusf/seaweedfs/weed/util"
+)
+
+func EnsureVisited(mc *MetaCache, client filer_pb.FilerClient, dirPath util.FullPath, entryChan chan *filer.Entry) error {
+
+	currentPath := dirPath
+
+	for {
+
+		// the directory children are already cached
+		// so no need for this and upper directories
+		if mc.isCachedFn(currentPath) {
+			return nil
+		}
+
+		if entryChan != nil && dirPath == currentPath {
+			if err := doEnsureVisited(mc, client, currentPath, entryChan); err != nil {
+				return err
+			}
+		} else {
+			if err := doEnsureVisited(mc, client, currentPath, nil); err != nil {
+				return err
+			}
+		}
+
+		// continue to parent directory
+		if currentPath != mc.root {
+			parent, _ := currentPath.DirAndName()
+			currentPath = util.FullPath(parent)
+		} else {
+			break
+		}
+	}
+
+	return nil
+
+}
+
+func doEnsureVisited(mc *MetaCache, client filer_pb.FilerClient, path util.FullPath, entryChan chan *filer.Entry) error {
+
+	glog.V(4).Infof("ReadDirAllEntries %s ...", path)
+
+	err := util.Retry("ReadDirAllEntries", func() error {
+		return filer_pb.ReadDirAllEntries(client, path, "", func(pbEntry *filer_pb.Entry, isLast bool) error {
+			entry := filer.FromPbEntry(string(path), pbEntry)
+			if IsHiddenSystemEntry(string(path), entry.Name()) {
+				return nil
+			}
+			if err := mc.doInsertEntry(context.Background(), entry); err != nil {
+				glog.V(0).Infof("read %s: %v", entry.FullPath, err)
+				return err
+			}
+			if entryChan != nil {
+				entryChan <- entry
+			}
+			return nil
+		})
+	})
+
+	if err != nil {
+		err = fmt.Errorf("list %s: %v", path, err)
+	}
+	mc.markCachedFn(path)
+	return err
+}
+
+func IsHiddenSystemEntry(dir, name string) bool {
+	return dir == "/" && (name == "topics" || name == "etc")
+}
@@ -36,7 +36,7 @@ func SubscribeMetaEvents(mc *MetaCache, selfSignature int32, client filer_pb.Fil
 			glog.V(4).Infof("creating %v", key)
 			newEntry = filer.FromPbEntry(dir, message.NewEntry)
 		}
-		err := mc.AtomicUpdateEntryFromFiler(context.Background(), oldPath, newEntry)
+		err := mc.AtomicUpdateEntryFromFiler(context.Background(), oldPath, newEntry, message.DeleteChunks)
 		if err == nil {
 			if message.OldEntry != nil && message.NewEntry != nil {
 				oldKey := util.NewFullPath(resp.Directory, message.OldEntry.Name)
@@ -45,9 +45,9 @@ func SubscribeMetaEvents(mc *MetaCache, selfSignature int32, client filer_pb.Fil
 					newKey := util.NewFullPath(dir, message.NewEntry.Name)
 					mc.invalidateFunc(newKey, message.NewEntry)
 				}
-			} else if message.OldEntry == nil && message.NewEntry != nil {
+			} else if filer_pb.IsCreate(resp) {
 				// no need to invaalidate
-			} else if message.OldEntry != nil && message.NewEntry == nil {
+			} else if filer_pb.IsDelete(resp) {
 				oldKey := util.NewFullPath(resp.Directory, message.OldEntry.Name)
 				mc.invalidateFunc(oldKey, message.OldEntry)
 			}
@@ -1,16 +1,15 @@
-package filesys
+package mount

 import (
-	"github.com/chrislusf/seaweedfs/weed/filesys/page_writer"
 	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/mount/page_writer"
 )

 type PageWriter struct {
-	fh            *FileHandle
-	collection    string
-	replication   string
-	chunkSize     int64
-	writerPattern *WriterPattern
+	fh          *FileHandle
+	collection  string
+	replication string
+	chunkSize   int64

 	randomWriter page_writer.DirtyPages
 }
@@ -21,10 +20,9 @@ var (

 func newPageWriter(fh *FileHandle, chunkSize int64) *PageWriter {
 	pw := &PageWriter{
-		fh:            fh,
-		chunkSize:     chunkSize,
-		writerPattern: NewWriterPattern(chunkSize),
-		randomWriter:  newMemoryChunkPages(fh, chunkSize),
+		fh:           fh,
+		chunkSize:    chunkSize,
+		randomWriter: newMemoryChunkPages(fh, chunkSize),
 		// randomWriter: newTempFileDirtyPages(fh.f, chunkSize),
 	}
 	return pw
@@ -32,7 +30,7 @@ func newPageWriter(fh *FileHandle, chunkSize int64) *PageWriter {

 func (pw *PageWriter) AddPage(offset int64, data []byte) {

-	glog.V(4).Infof("%v AddPage [%d, %d) streaming:%v", pw.fh.f.fullpath(), offset, offset+int64(len(data)), pw.writerPattern.IsStreamingMode())
+	glog.V(4).Infof("%v AddPage [%d, %d)", pw.fh.fh, offset, offset+int64(len(data)))

 	chunkIndex := offset / pw.chunkSize
 	for i := chunkIndex; len(data) > 0; i++ {
@@ -48,12 +46,11 @@ func (pw *PageWriter) addToOneChunk(chunkIndex, offset int64, data []byte) {
 }

 func (pw *PageWriter) FlushData() error {
-	pw.writerPattern.Reset()
 	return pw.randomWriter.FlushData()
 }

 func (pw *PageWriter) ReadDirtyDataAt(data []byte, offset int64) (maxStop int64) {
-	glog.V(4).Infof("ReadDirtyDataAt %v [%d, %d)", pw.fh.f.fullpath(), offset, offset+int64(len(data)))
+	glog.V(4).Infof("ReadDirtyDataAt %v [%d, %d)", pw.fh.fh, offset, offset+int64(len(data)))

 	chunkIndex := offset / pw.chunkSize
 	for i := chunkIndex; len(data) > 0; i++ {
@@ -51,6 +51,12 @@ func (list *ChunkWrittenIntervalList) MarkWritten(startOffset, stopOffset int64)
 func (list *ChunkWrittenIntervalList) IsComplete(chunkSize int64) bool {
 	return list.size() == 1 && list.head.next.isComplete(chunkSize)
 }
+func (list *ChunkWrittenIntervalList) WrittenSize() (writtenByteCount int64) {
+	for t := list.head; t != nil; t = t.next {
+		writtenByteCount += t.Size()
+	}
+	return
+}

 func (list *ChunkWrittenIntervalList) addInterval(interval *ChunkWrittenInterval) {

--- a/Show More
+++ b/Show More