Finish the first version of propfind.

rest/dav/file.go

@@ -17,9 +17,9 @@ import (
 	"time"
 )
 
-// slashClean is equivalent to but slightly more efficient than
+// SlashClean is equivalent to but slightly more efficient than
 // path.Clean("/" + name).
-func slashClean(name string) string {
+func SlashClean(name string) string {
 	if name == "" || name[0] != '/' {
 		name = "/" + name
 	}
@@ -74,7 +74,7 @@ func (d Dir) resolve(name string) string {
 	if dir == "" {
 		dir = "."
 	}
-	return filepath.Join(dir, filepath.FromSlash(slashClean(name)))
+	return filepath.Join(dir, filepath.FromSlash(SlashClean(name)))
 }
 
 func (d Dir) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
@@ -166,7 +166,7 @@ type memFS struct {
 // ends at that root node.
 func (fs *memFS) walk(op, fullname string, f func(dir *memFSNode, frag string, final bool) error) error {
 	original := fullname
-	fullname = slashClean(fullname)
+	fullname = SlashClean(fullname)
 
 	// Strip any leading "/"s to make fullname a relative path, as the walk
 	// starts at fs.root.
@@ -335,8 +335,8 @@ func (fs *memFS) Rename(ctx context.Context, oldName, newName string) error {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
-	oldName = slashClean(oldName)
-	newName = slashClean(newName)
+	oldName = SlashClean(oldName)
+	newName = SlashClean(newName)
 	if oldName == newName {
 		return nil
 	}

rest/dav/file_test.go

@@ -37,7 +37,7 @@ func TestSlashClean(t *testing.T) {
 		"a/b/c",
 	}
 	for _, tc := range testCases {
-		got := slashClean(tc)
+		got := SlashClean(tc)
 		want := path.Clean("/" + tc)
 		if got != want {
 			t.Errorf("tc=%q: got %q, want %q", tc, got, want)

rest/dav/lock.go

@@ -151,12 +151,12 @@ func (m *memLS) Confirm(now time.Time, name0, name1 string, conditions ...Condit
 
 	var n0, n1 *memLSNode
 	if name0 != "" {
-		if n0 = m.lookup(slashClean(name0), conditions...); n0 == nil {
+		if n0 = m.lookup(SlashClean(name0), conditions...); n0 == nil {
 			return nil, ErrConfirmationFailed
 		}
 	}
 	if name1 != "" {
-		if n1 = m.lookup(slashClean(name1), conditions...); n1 == nil {
+		if n1 = m.lookup(SlashClean(name1), conditions...); n1 == nil {
 			return nil, ErrConfirmationFailed
 		}
 	}
@@ -233,7 +233,7 @@ func (m *memLS) Create(now time.Time, details LockDetails) (string, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.collectExpiredNodes(now)
-	details.Root = slashClean(details.Root)
+	details.Root = SlashClean(details.Root)
 
 	if !m.canCreate(details.Root, details.ZeroDepth) {
 		return "", ErrLocked

rest/dav/prop.go

@@ -336,7 +336,7 @@ loop:
 	return []Propstat{pstat}, nil
 }
 
-func escapeXML(s string) string {
+func EscapeXML(s string) string {
 	for i := 0; i < len(s); i++ {
 		// As an optimization, if s contains only ASCII letters, digits or a
 		// few special characters, the escaped value is s itself and we don't
@@ -364,11 +364,11 @@ func findResourceType(ctx context.Context, fs FileSystem, ls LockSystem, name st
 }
 
 func findDisplayName(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
-	if slashClean(name) == "/" {
+	if SlashClean(name) == "/" {
 		// Hide the real name of a possibly prefixed root directory.
 		return "", nil
 	}
-	return escapeXML(fi.Name()), nil
+	return EscapeXML(fi.Name()), nil
 }
 
 func findContentLength(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {

rest/dav/webdav_test.go

@@ -208,7 +208,7 @@ func TestEscapeXML(t *testing.T) {
 	// These test cases aren't exhaustive, and there is more than one way to
 	// escape e.g. a quot (as """ or """) or an apos. We presume that
 	// the encoding/xml package tests xml.EscapeText more thoroughly. This test
-	// here is just a sanity check for this package's escapeXML function, and
+	// here is just a sanity check for this package's EscapeXML function, and
 	// its attempt to provide a fast path (and avoid a bytes.Buffer allocation)
 	// when escaping filenames is obviously a no-op.
 	testCases := map[string]string{
@@ -236,7 +236,7 @@ func TestEscapeXML(t *testing.T) {
 	}
 
 	for in, want := range testCases {
-		if got := escapeXML(in); got != want {
+		if got := EscapeXML(in); got != want {
 			t.Errorf("in=%q: got %q, want %q", in, got, want)
 		}
 	}

rest/dav_controller.go

@@ -1,6 +1,7 @@
 package rest
 
 import (
+	"fmt"
 	"net/http"
 	"regexp"
 	"tank/rest/dav"
@@ -80,7 +81,8 @@ func (this *DavController) HandleRoutes(writer http.ResponseWriter, request *htt
 	path := request.URL.Path
 
 	//匹配 /api/dav{subPath}
-	reg := regexp.MustCompile(`^/api/dav(.*)$`)
+	pattern := fmt.Sprintf(`^%s(.*)$`, WEBDAV_PREFFIX)
+	reg := regexp.MustCompile(pattern)
 	strs := reg.FindStringSubmatch(path)
 	if len(strs) == 2 {
 		var f = func(writer http.ResponseWriter, request *http.Request) {

rest/dav_model.go

@@ -1,3 +1,102 @@
 package rest
 
+import (
+	"encoding/xml"
+	"fmt"
+	"net/http"
+	"strconv"
+	"tank/rest/dav"
+)
 
+//访问前缀，这个是特殊入口
+var WEBDAV_PREFFIX = "/api/dav"
+
+//动态的文件属性
+type LiveProp struct {
+	findFn func(matter *Matter) string
+	dir    bool
+}
+
+//所有的动态属性定义及其值的获取方式
+var LivePropMap = map[xml.Name]LiveProp{
+	{Space: "DAV:", Local: "resourcetype"}: {
+		findFn: func(matter *Matter) string {
+			if matter.Dir {
+				return `<D:collection xmlns:D="DAV:"/>`
+			} else {
+				return ""
+			}
+		},
+		dir: true,
+	},
+	{Space: "DAV:", Local: "displayname"}: {
+		findFn: func(matter *Matter) string {
+			if dav.SlashClean(matter.Name) == "/" {
+				return ""
+			} else {
+				return dav.EscapeXML(matter.Name)
+			}
+		},
+		dir: true,
+	},
+	{Space: "DAV:", Local: "getcontentlength"}: {
+		findFn: func(matter *Matter) string {
+			return strconv.FormatInt(matter.Size, 10)
+		},
+		dir: false,
+	},
+	{Space: "DAV:", Local: "getlastmodified"}: {
+		findFn: func(matter *Matter) string {
+			return matter.UpdateTime.UTC().Format(http.TimeFormat)
+		},
+		// http://webdav.org/specs/rfc4918.html#PROPERTY_getlastmodified
+		// suggests that getlastmodified should only apply to GETable
+		// resources, and this package does not support GET on directories.
+		//
+		// Nonetheless, some WebDAV clients expect child directories to be
+		// sortable by getlastmodified date, so this value is true, not false.
+		// See golang.org/issue/15334.
+		dir: true,
+	},
+	{Space: "DAV:", Local: "creationdate"}: {
+		findFn: nil,
+		dir:    false,
+	},
+	{Space: "DAV:", Local: "getcontentlanguage"}: {
+		findFn: nil,
+		dir:    false,
+	},
+	{Space: "DAV:", Local: "getcontenttype"}: {
+		findFn: func(matter *Matter) string {
+			if matter.Dir {
+				return ""
+			} else {
+				return dav.EscapeXML(matter.Name)
+			}
+		},
+		dir: false,
+	},
+	{Space: "DAV:", Local: "getetag"}: {
+		findFn: func(matter *Matter) string {
+			return fmt.Sprintf(`"%x%x"`, matter.UpdateTime.UnixNano(), matter.Size)
+		},
+		// findETag implements ETag as the concatenated hex values of a file's
+		// modification time and size. This is not a reliable synchronization
+		// mechanism for directories, so we do not advertise getetag for DAV
+		// collections.
+		dir: false,
+	},
+	// TODO: The lockdiscovery property requires LockSystem to list the
+	// active locks on a resource.
+	{Space: "DAV:", Local: "lockdiscovery"}: {},
+	{Space: "DAV:", Local: "supportedlock"}: {
+		findFn: func(matter *Matter) string {
+			return `` +
+				`<D:lockentry xmlns:D="DAV:">` +
+				`<D:lockscope><D:exclusive/></D:lockscope>` +
+				`<D:locktype><D:write/></D:locktype>` +
+				`</D:lockentry>`
+		},
+		dir: true,
+	},
+}

rest/dav_service.go

@@ -58,6 +58,48 @@ func (this *DavService) PropNames(matter *Matter) []xml.Name {
 
 }
 
+
+//从一个matter中获取其 []dav.Propstat
+func (this *DavService) Propstats(matter *Matter, propfind dav.Propfind) []dav.Propstat {
+
+	propstats := make([]dav.Propstat, 0)
+	if propfind.Propname != nil {
+		this.PanicBadRequest("propfind.Propname != nil 尚未处理")
+	} else if propfind.Allprop != nil {
+		this.PanicBadRequest("propfind.Allprop != nil 尚未处理")
+	} else {
+
+		var properties []dav.Property
+
+		for _, prop := range propfind.Prop {
+			//TODO: deadprops尚未考虑
+
+			// Otherwise, it must either be a live property or we don't know it.
+			if liveProp := LivePropMap[prop]; liveProp.findFn != nil && (liveProp.dir || !matter.Dir) {
+				innerXML := liveProp.findFn(matter)
+
+				properties = append(properties, dav.Property{
+					XMLName:  prop,
+					InnerXML: []byte(innerXML),
+				})
+			} else {
+				//TODO: 某一项请求的prop没有对应的结果
+			}
+		}
+
+		if len(properties) == 0 {
+			this.PanicBadRequest("请求的属性项无法解析！")
+		}
+
+		okPropstat := dav.Propstat{Status: http.StatusOK, Props: properties}
+
+		propstats = append(propstats, okPropstat)
+	}
+
+	return propstats
+
+}
+
 //处理 方法
 func (this *DavService) HandlePropfind(writer http.ResponseWriter, request *http.Request, subPath string) {
 
@@ -84,19 +126,11 @@ func (this *DavService) HandlePropfind(writer http.ResponseWriter, request *http
 
 	for _, matter := range matters {
 
-		fmt.Printf("开始分析 %s\n", matter.Name)
+		fmt.Printf("开始分析 %s\n", matter.Path)
 
-		var propstats []dav.Propstat
-		var props = make([]dav.Property, 0)
-		props = append(props, dav.Property{
-			XMLName: xml.Name{Space: "DAV:"},
-		})
-		propstats = append(propstats, dav.Propstat{
-			Props:               props,
-			ResponseDescription: "有点问题",
-		})
-
-		response := this.makePropstatResponse("/eyeblue/ready/go", propstats)
+		propstats := this.Propstats(matter, propfind)
+		path := fmt.Sprintf("%s%s", WEBDAV_PREFFIX, matter.Path)
+		response := this.makePropstatResponse(path, propstats)
 
 		err = multiStatusWriter.Write(response)
 		this.PanicError(err)

rest/matter_model.go

@@ -29,11 +29,19 @@ func (Matter) TableName() string {
 	return TABLE_PREFIX + "matter"
 }
 
+
 // 获取该Matter的绝对路径。path代表的是相对路径。
 func (this *Matter) AbsolutePath() string {
 	return GetUserFileRootDir(this.Username) + this.Path
 }
 
+
+// 获取该Matter的MimeType
+func (this *Matter) MimeType() string {
+	return GetMimeType(GetExtension(this.Name))
+}
+
+
 //创建一个 ROOT 的matter，主要用于统一化处理移动复制等内容。
 func NewRootMatter(user *User) *Matter {
 	matter := &Matter{}