micro/util/file/client.go

192 lines
4.1 KiB
Go
Raw Normal View History

package file
import (
"bufio"
"context"
"errors"
"fmt"
"io"
"log"
"os"
"github.com/unistack-org/micro/v3/client"
proto "github.com/unistack-org/micro/v3/util/file/proto"
)
// Client is the client interface to access files
type File interface {
Open(filename string, truncate bool) (int64, error)
Stat(filename string) (*proto.StatResponse, error)
GetBlock(sessionId, blockId int64) ([]byte, error)
ReadAt(sessionId, offset, size int64) ([]byte, error)
Read(sessionId int64, buf []byte) (int, error)
Write(sessionId, offset int64, data []byte) error
Close(sessionId int64) error
Download(filename, saveFile string) error
Upload(filename, localFile string) error
DownloadAt(filename, saveFile string, blockId int) error
}
// NewClient returns a new Client which uses a micro Client
func New(service string, c client.Client) File {
return &fc{proto.NewFileService(service, c)}
}
const (
blockSize = 512 * 1024
)
type fc struct {
c proto.FileService
}
func (c *fc) Open(filename string, truncate bool) (int64, error) {
rsp, err := c.c.Open(context.TODO(), &proto.OpenRequest{
Filename: filename,
Truncate: truncate,
})
if err != nil {
return 0, err
}
return rsp.Id, nil
}
func (c *fc) Stat(filename string) (*proto.StatResponse, error) {
return c.c.Stat(context.TODO(), &proto.StatRequest{Filename: filename})
}
func (c *fc) GetBlock(sessionId, blockId int64) ([]byte, error) {
return c.ReadAt(sessionId, blockId*blockSize, blockSize)
}
func (c *fc) ReadAt(sessionId, offset, size int64) ([]byte, error) {
rsp, err := c.c.Read(context.TODO(), &proto.ReadRequest{Id: sessionId, Size: size, Offset: offset})
if err != nil {
return nil, err
}
if rsp.Eof {
err = io.EOF
}
if rsp.Data == nil {
rsp.Data = make([]byte, size)
}
if size != rsp.Size {
return rsp.Data[:rsp.Size], err
}
return rsp.Data, nil
}
func (c *fc) Read(sessionId int64, buf []byte) (int, error) {
b, err := c.ReadAt(sessionId, 0, int64(cap(buf)))
if err != nil {
return 0, err
}
copy(buf, b)
return len(b), nil
}
func (c *fc) Write(sessionId, offset int64, data []byte) error {
_, err := c.c.Write(context.TODO(), &proto.WriteRequest{
Id: sessionId,
Offset: offset,
Data: data})
return err
}
func (c *fc) Close(sessionId int64) error {
_, err := c.c.Close(context.TODO(), &proto.CloseRequest{Id: sessionId})
return err
}
func (c *fc) Download(filename, saveFile string) error {
return c.DownloadAt(filename, saveFile, 0)
}
func (c *fc) Upload(filename, localFile string) error {
file, err := os.Open(localFile)
if err != nil {
return err
}
defer file.Close()
offset := 0
sessionId, err := c.Open(filename, true)
defer c.Close(sessionId)
if err != nil {
return err
}
reader := bufio.NewReader(file)
part := make([]byte, blockSize)
for {
count, err := reader.Read(part)
if err != nil {
break
}
err = c.Write(sessionId, int64(offset), part)
if err != nil {
return err
}
offset += count
}
if err != nil && err != io.EOF {
return fmt.Errorf("Error reading %v: %v", localFile, err)
}
return nil
}
func (c *fc) DownloadAt(filename, saveFile string, blockId int) error {
stat, err := c.Stat(filename)
if err != nil {
return err
}
if stat.Type == "Directory" {
return errors.New(fmt.Sprintf("%s is directory.", filename))
}
blocks := int(stat.Size / blockSize)
if stat.Size%blockSize != 0 {
blocks += 1
}
log.Printf("Download %s in %d blocks\n", filename, blocks-blockId)
file, err := os.OpenFile(saveFile, os.O_CREATE|os.O_WRONLY, 0666)
if err != nil {
return err
}
defer file.Close()
sessionId, err := c.Open(filename, false)
if err != nil {
return err
}
for i := blockId; i < blocks; i++ {
buf, rerr := c.GetBlock(sessionId, int64(i))
if rerr != nil && rerr != io.EOF {
return rerr
}
if _, werr := file.WriteAt(buf, int64(i)*blockSize); werr != nil {
return werr
}
if i%((blocks-blockId)/100+1) == 0 {
log.Printf("Downloading %s [%d/%d] blocks", filename, i-blockId+1, blocks-blockId)
}
if rerr == io.EOF {
break
}
}
log.Printf("Download %s completed", filename)
c.Close(sessionId)
return nil
}