snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/admin/dash/file_browser_data.go

@@ -0,0 +1,334 @@
+package dash
+
+import (
+	"context"
+	"net/url"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
+	"github.com/seaweedfs/seaweedfs/weed/s3api/s3tables"
+)
+
+// FileEntry represents a file or directory entry in the file browser
+type FileEntry struct {
+	Name        string    `json:"name"`
+	FullPath    string    `json:"full_path"`
+	IsDirectory bool      `json:"is_directory"`
+	Size        int64     `json:"size"`
+	ModTime     time.Time `json:"mod_time"`
+	Mode        string    `json:"mode"`
+	Uid         uint32    `json:"uid"`
+	Gid         uint32    `json:"gid"`
+	Mime        string    `json:"mime"`
+	Replication string    `json:"replication"`
+	Collection  string    `json:"collection"`
+	TtlSec      int32     `json:"ttl_sec"`
+}
+
+// BreadcrumbItem represents a single breadcrumb in the navigation
+type BreadcrumbItem struct {
+	Name string `json:"name"`
+	Path string `json:"path"`
+}
+
+// FileBrowserData contains all data needed for the file browser view
+type FileBrowserData struct {
+	Username    string           `json:"username"`
+	CurrentPath string           `json:"current_path"`
+	ParentPath  string           `json:"parent_path"`
+	Breadcrumbs []BreadcrumbItem `json:"breadcrumbs"`
+	Entries     []FileEntry      `json:"entries"`
+
+	LastUpdated       time.Time `json:"last_updated"`
+	IsBucketPath      bool      `json:"is_bucket_path"`
+	BucketName        string    `json:"bucket_name"`
+	IsTableBucketPath bool      `json:"is_table_bucket_path"`
+	TableBucketName   string    `json:"table_bucket_name"`
+	S3Endpoint        string    `json:"s3_endpoint,omitempty"`
+	// Pagination fields
+	PageSize            int    `json:"page_size"`
+	HasNextPage         bool   `json:"has_next_page"`
+	LastFileName        string `json:"last_file_name"`         // Cursor for next page
+	CurrentLastFileName string `json:"current_last_file_name"` // Cursor from current request (for page size changes)
+}
+
+// GetFileBrowser retrieves file browser data for a given path with cursor-based
+// pagination. A non-empty prefix limits the listing to entries whose name starts
+// with it, so callers that only want part of a large directory don't have to page
+// through all of it.
+func (s *AdminServer) GetFileBrowser(dir string, prefix string, lastFileName string, pageSize int) (*FileBrowserData, error) {
+	if dir == "" {
+		dir = "/"
+	}
+
+	// Set defaults for pagination
+	if pageSize < 1 {
+		pageSize = 20 // Default page size
+	}
+
+	var entries []FileEntry
+
+	// Fetch entries using cursor-based pagination
+	// We fetch pageSize+1 to determine if there's a next page
+	fetchLimit := pageSize + 1
+	var fetchedCount int
+	var lastEntryName string
+
+	err := s.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
+		// Fetch entries starting from the cursor (lastFileName)
+		stream, err := client.ListEntries(context.Background(), &filer_pb.ListEntriesRequest{
+			Directory:          dir,
+			Prefix:             prefix,
+			Limit:              uint32(fetchLimit),
+			StartFromFileName:  lastFileName,
+			InclusiveStartFrom: false, // Don't include the cursor file itself
+		})
+		if err != nil {
+			return err
+		}
+
+		for {
+			resp, err := stream.Recv()
+			if err != nil {
+				if err.Error() == "EOF" {
+					break
+				}
+				return err
+			}
+
+			entry := resp.Entry
+			if entry == nil {
+				continue
+			}
+
+			fetchedCount++
+
+			// Only add entries up to pageSize (the +1 is just to check for next page)
+			if fetchedCount <= pageSize {
+				fullPath := path.Join(dir, entry.Name)
+
+				var modTime time.Time
+				if entry.Attributes != nil && entry.Attributes.Mtime > 0 {
+					modTime = time.Unix(entry.Attributes.Mtime, 0)
+				}
+
+				var mode string
+				var uid, gid uint32
+				var size int64
+				var replication, collection string
+				var ttlSec int32
+
+				if entry.Attributes != nil {
+					mode = FormatFileMode(entry.Attributes.FileMode)
+					uid = entry.Attributes.Uid
+					gid = entry.Attributes.Gid
+					size = int64(entry.Attributes.FileSize)
+					ttlSec = entry.Attributes.TtlSec
+				}
+
+				// Get replication and collection from entry extended attributes
+				if entry.Extended != nil {
+					if repl, ok := entry.Extended["replication"]; ok {
+						replication = string(repl)
+					}
+					if coll, ok := entry.Extended["collection"]; ok {
+						collection = string(coll)
+					}
+				}
+
+				mime := ResolveEntryMime(entry)
+
+				fileEntry := FileEntry{
+					Name:        entry.Name,
+					FullPath:    fullPath,
+					IsDirectory: entry.IsDirectory,
+					Size:        size,
+					ModTime:     modTime,
+					Mode:        mode,
+					Uid:         uid,
+					Gid:         gid,
+					Mime:        mime,
+					Replication: replication,
+					Collection:  collection,
+					TtlSec:      ttlSec,
+				}
+
+				entries = append(entries, fileEntry)
+
+				lastEntryName = entry.Name
+
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	// Determine if there's a next page
+	hasNextPage := fetchedCount > pageSize
+
+	// Generate breadcrumbs
+	breadcrumbs := s.generateBreadcrumbs(dir)
+
+	// Calculate parent path
+	parentPath := "/"
+	if dir != "/" {
+		parentPath = path.Dir(dir)
+		if parentPath == "." {
+			parentPath = "/"
+		}
+	}
+
+	// Check if this is a bucket path and determine if it's a table bucket
+	isBucketPath := false
+	bucketName := ""
+	isTableBucketPath := false
+	tableBucketName := ""
+	isRegularBucket := false
+	if strings.HasPrefix(dir, "/buckets/") {
+		isBucketPath = true
+		pathParts := strings.Split(strings.Trim(dir, "/"), "/")
+		if len(pathParts) >= 2 {
+			bucketName = pathParts[1]
+			// Check table bucket status early to avoid second WithFilerClient call
+			if err := s.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
+				resp, err := filer_pb.LookupEntry(context.Background(), client, &filer_pb.LookupDirectoryEntryRequest{
+					Directory: "/buckets",
+					Name:      bucketName,
+				})
+				if err != nil {
+					return err
+				}
+				if s3tables.IsTableBucketEntry(resp.Entry) {
+					isTableBucketPath = true
+					tableBucketName = bucketName
+				} else {
+					isRegularBucket = true
+				}
+				return nil
+			}); err != nil {
+				glog.V(1).Infof("file browser table bucket lookup failed for %s: %v", bucketName, err)
+			}
+		}
+	}
+
+	s3Endpoint := ""
+	if isRegularBucket {
+		s3Endpoint = s.GetS3Endpoint()
+	}
+
+	return &FileBrowserData{
+		CurrentPath: dir,
+		ParentPath:  parentPath,
+		Breadcrumbs: breadcrumbs,
+		Entries:     entries,
+
+		LastUpdated:       time.Now(),
+		IsBucketPath:      isBucketPath,
+		BucketName:        bucketName,
+		IsTableBucketPath: isTableBucketPath,
+		TableBucketName:   tableBucketName,
+		S3Endpoint:        s3Endpoint,
+		// Pagination metadata
+		PageSize:            pageSize,
+		HasNextPage:         hasNextPage,
+		LastFileName:        lastEntryName, // Store for next page navigation
+		CurrentLastFileName: lastFileName,  // Store input cursor for page size changes
+	}, nil
+}
+
+// generateBreadcrumbs creates breadcrumb navigation for the current path
+func (s *AdminServer) generateBreadcrumbs(dir string) []BreadcrumbItem {
+	var breadcrumbs []BreadcrumbItem
+
+	// Always start with root
+	breadcrumbs = append(breadcrumbs, BreadcrumbItem{
+		Name: "Root",
+		Path: "/",
+	})
+
+	if dir == "/" {
+		return breadcrumbs
+	}
+
+	// Split path and build breadcrumbs
+	parts := strings.Split(strings.Trim(dir, "/"), "/")
+	currentPath := ""
+
+	for _, part := range parts {
+		if part == "" {
+			continue
+		}
+		currentPath += "/" + part
+
+		// Special handling for bucket paths
+		displayName := part
+		if len(breadcrumbs) == 1 && part == "buckets" {
+			displayName = "Object Store Buckets"
+		} else if len(breadcrumbs) == 2 && strings.HasPrefix(dir, "/buckets/") {
+			displayName = "📦 " + part // Add bucket icon to bucket name
+		}
+
+		breadcrumbs = append(breadcrumbs, BreadcrumbItem{
+			Name: displayName,
+			Path: currentPath,
+		})
+	}
+
+	return breadcrumbs
+}
+
+// S3ObjectURL builds the path-style S3 URL for a filer path under /buckets/,
+// percent-encoding each path segment. Returns "" for other paths.
+func S3ObjectURL(endpoint, fullPath string) string {
+	rel, ok := strings.CutPrefix(fullPath, "/buckets/")
+	if !ok || rel == "" || endpoint == "" {
+		return ""
+	}
+	segments := strings.Split(rel, "/")
+	for i, segment := range segments {
+		segments[i] = url.PathEscape(segment)
+	}
+	return strings.TrimRight(endpoint, "/") + "/" + strings.Join(segments, "/")
+}
+
+// GetS3ObjectURL returns the S3 URL an object under a regular bucket is served
+// at, or "" when the path is not a bucket object, the bucket is an S3 Tables
+// bucket, or no S3 endpoint is known.
+func (s *AdminServer) GetS3ObjectURL(fullPath string) string {
+	rel, ok := strings.CutPrefix(fullPath, "/buckets/")
+	if !ok {
+		return ""
+	}
+	bucketName, key, found := strings.Cut(rel, "/")
+	if !found || key == "" {
+		return ""
+	}
+	endpoint := s.GetS3Endpoint()
+	if endpoint == "" {
+		return ""
+	}
+	if err := s.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
+		resp, err := filer_pb.LookupEntry(context.Background(), client, &filer_pb.LookupDirectoryEntryRequest{
+			Directory: "/buckets",
+			Name:      bucketName,
+		})
+		if err != nil {
+			return err
+		}
+		if s3tables.IsTableBucketEntry(resp.Entry) {
+			endpoint = ""
+		}
+		return nil
+	}); err != nil {
+		glog.V(1).Infof("object url bucket lookup failed for %s: %v", bucketName, err)
+		return ""
+	}
+	return S3ObjectURL(endpoint, fullPath)
+}