From 18e2a61c8aca343e772dc2f78ac33dff69ecc29c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9E=D0=BB=D0=B5=D0=B3=20=D0=91=D0=BE=D1=80=D0=BE=D0=B4?= =?UTF-8?q?=D0=B8=D0=BD?= Date: Sun, 1 Feb 2026 21:03:43 +0200 Subject: [PATCH] working commit --- app/handler/file.go | 33 ++++++++-- app/operator/file.go | 122 +++++++++++++++++++++++++++-------- app/router/pathc.go | 2 +- app/service/service.go | 1 + app/storage/storage.go | 50 ++++++++++++--- pkg/client/cliaux.go | 48 ++++++++++++++ pkg/client/client.go | 130 ++++++++++++++++++++++++-------------- pkg/client/client_test.go | 89 ++++++++++++++++++++++++++ test/file_test.go | 29 +++++---- test/server_test.go | 17 +++-- 10 files changed, 410 insertions(+), 111 deletions(-) create mode 100644 pkg/client/cliaux.go create mode 100644 pkg/client/client_test.go diff --git a/app/handler/file.go b/app/handler/file.go index 67256f1..0d661dc 100644 --- a/app/handler/file.go +++ b/app/handler/file.go @@ -22,7 +22,7 @@ func (hand *Handler) FileExists(rctx *router.Context) { return } rctx.SetHeader("Content-Type", res.ContentType) - rctx.SetHeader("Content-Length", res.ContentLength) + rctx.SetHeader("Content-Size", res.ContentSize) rctx.SetHeader("Content-Digest", res.ContentDigest) rctx.SetStatus(code) @@ -31,15 +31,17 @@ func (hand *Handler) FileExists(rctx *router.Context) { func (hand *Handler) PutFile(rctx *router.Context) { hand.logg.Debugf("Handle PutFile") - contentLength := rctx.GetHeader("Content-Length") + contentSize := rctx.GetHeader("Content-Size") contentType := rctx.GetHeader("Content-Type") filepath := rctx.PathMap["filepath"] + hand.logg.Debugf("%s", contentSize) + params := &operator.PutFileParams{ - Filepath: filepath, - ContentLength: contentLength, - ContentType: contentType, - Source: rctx.Request.Body, + Filepath: filepath, + ContentSize: contentSize, + ContentType: contentType, + Source: rctx.Request.Body, } code, _, err := hand.oper.PutFile(params) if err != nil { @@ -67,7 +69,7 @@ func (hand *Handler) GetFile(rctx *router.Context) { } rctx.SetStatus(code) rctx.SetHeader("Content-Type", res.ContentType) - rctx.SetHeader("Content-Length", res.ContentLength) + rctx.SetHeader("Content-Size", res.ContentSize) rctx.SetHeader("Content-Digest", res.ContentDigest) if res.Source != nil { @@ -93,3 +95,20 @@ func (hand *Handler) DeleteFile(rctx *router.Context) { } rctx.SetStatus(code) } + +func (hand *Handler) ListFiles(rctx *router.Context) { + hand.logg.Debugf("Handle ListFiles") + + filepath := rctx.PathMap["filepath"] + params := &operator.ListFilesParams{ + Filepath: filepath, + } + code, res, err := hand.oper.ListFiles(params) + if err != nil { + hand.logg.Errorf("ListFiles error: %v", err) + rctx.SetStatus(code) + return + } + rctx.SetStatus(code) + rctx.SendJSON(res) +} diff --git a/app/operator/file.go b/app/operator/file.go index 9f40eba..03b8bf7 100644 --- a/app/operator/file.go +++ b/app/operator/file.go @@ -1,9 +1,11 @@ package operator import ( + "fmt" "io" "net/http" "path" + "path/filepath" "strconv" "mstore/app/descr" @@ -11,7 +13,7 @@ import ( "mstore/pkg/auxuuid" ) -// File exists +// FileExists type FileExistsParams struct { Filepath string Source string @@ -19,37 +21,52 @@ type FileExistsParams struct { } type FileExistsResult struct { ContentType string - ContentLength string + ContentSize string ContentDigest string } +func cleanFilepath(filename string) (string, error) { + filename = "/" + filename + return filepath.Clean(filename), nil +} + func (oper *Operator) FileExists(param *FileExistsParams) (int, *FileExistsResult, error) { var err error code := http.StatusOK res := &FileExistsResult{} - filename := path.Base(param.Filepath) - collection := path.Dir(param.Filepath) + xfilepath, err := cleanFilepath(param.Filepath) + if err != nil { + code := http.StatusInternalServerError + return code, res, err + } + + filename := path.Base(xfilepath) + collection := path.Dir(xfilepath) exist, fileDescr, err := oper.mdb.GetFileByCollection(collection, filename) + if err != nil { + code := http.StatusInternalServerError + return code, res, err + } if !exist { code = http.StatusNotFound return code, res, err } res = &FileExistsResult{ - ContentLength: strconv.FormatInt(fileDescr.Size, 10), + ContentSize: strconv.FormatInt(fileDescr.Size, 10), ContentType: fileDescr.Type, ContentDigest: fileDescr.Checksum, } return code, res, err } -// Put file +// PutFile type PutFileParams struct { - ContentType string - ContentLength string - Filepath string - Source io.ReadCloser + ContentType string + ContentSize string + Filepath string + Source io.ReadCloser } type PutFileResult struct{} @@ -59,7 +76,12 @@ func (oper *Operator) PutFile(param *PutFileParams) (int, *PutFileResult, error) var err error res := &PutFileResult{} - size, err := strconv.ParseInt(param.ContentLength, 10, 64) + if param.ContentSize == "" { + code := http.StatusLengthRequired + err = fmt.Errorf("Content-Size is empty") + return code, res, err + } + size, err := strconv.ParseInt(param.ContentSize, 10, 64) if err != nil { code := http.StatusLengthRequired return code, res, err @@ -70,10 +92,15 @@ func (oper *Operator) PutFile(param *PutFileParams) (int, *PutFileResult, error) } // TODO: convert file path to a unified and secure state + xfilepath, err := cleanFilepath(param.Filepath) + if err != nil { + code := http.StatusInternalServerError + return code, res, err + } + filename := path.Base(xfilepath) + collection := path.Dir(xfilepath) - filename := path.Base(param.Filepath) - collection := path.Dir(param.Filepath) - oper.logg.Debugf("Put file %s %s", collection, filename) + oper.logg.Debugf("Put file [%s] [%s]", collection, filename) tmpname, size, checksum, err := oper.store.WriteTempFile(param.Source) if err != nil { @@ -125,13 +152,13 @@ func (oper *Operator) PutFile(param *PutFileParams) (int, *PutFileResult, error) return code, res, err } -// Get file +// GetFile type GetFileParams struct { Filepath string } type GetFileResult struct { ContentType string - ContentLength string + ContentSize string ContentDigest string Source io.ReadCloser } @@ -142,10 +169,15 @@ func (oper *Operator) GetFile(param *GetFileParams) (int, *GetFileResult, error) // TODO: convert file path to a unified and secure state - filename := path.Base(param.Filepath) - collection := path.Dir(param.Filepath) + xfilepath, err := cleanFilepath(param.Filepath) + if err != nil { + code := http.StatusInternalServerError + return code, res, err + } + filename := path.Base(xfilepath) + collection := path.Dir(xfilepath) - oper.logg.Debugf("Gut file %s %s", collection, filename) + oper.logg.Debugf("Get file [%s] [%s]", collection, filename) descrExists, fileDescr, err := oper.mdb.GetFileByCollection(collection, filename) if err != nil { @@ -162,7 +194,7 @@ func (oper *Operator) GetFile(param *GetFileParams) (int, *GetFileResult, error) return code, res, err } res = &GetFileResult{ - ContentLength: strconv.FormatInt(fileDescr.Size, 10), + ContentSize: strconv.FormatInt(fileDescr.Size, 10), ContentType: fileDescr.Type, ContentDigest: fileDescr.Checksum, Source: reader, @@ -171,7 +203,7 @@ func (oper *Operator) GetFile(param *GetFileParams) (int, *GetFileResult, error) return code, res, err } -// Delete file +// DeleteFile type DeleteFileParams struct { Filepath string } @@ -182,8 +214,13 @@ func (oper *Operator) DeleteFile(param *DeleteFileParams) (int, *DeleteFileResul res := &DeleteFileResult{} code := http.StatusOK - filename := path.Base(param.Filepath) - collection := path.Dir(param.Filepath) + xfilepath, err := cleanFilepath(param.Filepath) + if err != nil { + code := http.StatusInternalServerError + return code, res, err + } + filename := path.Base(xfilepath) + collection := path.Dir(xfilepath) exist, _, err := oper.mdb.GetFileByCollection(collection, filename) if err != nil { @@ -202,7 +239,42 @@ func (oper *Operator) DeleteFile(param *DeleteFileParams) (int, *DeleteFileResul code = http.StatusInternalServerError return code, res, err } - return code, res, err - +} + +// ListFiles +type ListFilesParams struct { + Filepath string +} +type ListFilesResult struct { + FileDescrs []descr.File +} + +func (oper *Operator) ListFiles(param *ListFilesParams) (int, *ListFilesResult, error) { + var err error + res := &ListFilesResult{ + FileDescrs: make([]descr.File, 0), + } + + // TODO: convert file path to a unified and secure state + + xfilepath, err := cleanFilepath(param.Filepath) + if err != nil { + code := http.StatusInternalServerError + return code, res, err + } + collection := xfilepath + + oper.logg.Debugf("List files by %s", collection) + + fileDescrs, err := oper.mdb.ListAllFiles() + if err != nil { + code := http.StatusInternalServerError + return code, res, err + } + for _, item := range fileDescrs { + res.FileDescrs = append(res.FileDescrs, item) + } + code := http.StatusOK + return code, res, err } diff --git a/app/router/pathc.go b/app/router/pathc.go index bb8ba65..bd367e4 100644 --- a/app/router/pathc.go +++ b/app/router/pathc.go @@ -56,7 +56,7 @@ func pathCompiler(path string) (string, error) { } const ( - defaultRegexp = `[a-zA-Z0-9_][/\-\.a-zA-Z0-9_%%=:~]+` + defaultRegexp = `[a-zA-Z0-9_\.][/\-\.a-zA-Z0-9_%%=:~]+` ) func convertRegexp(src []byte) []byte { diff --git a/app/service/service.go b/app/service/service.go index b5793c0..832ecf7 100644 --- a/app/service/service.go +++ b/app/service/service.go @@ -61,6 +61,7 @@ func (svc *Service) Build() error { svc.rout.Put("/v3/api/file/{filepath}", svc.hand.PutFile) svc.rout.Get("/v3/api/file/{filepath}", svc.hand.GetFile) svc.rout.Delete("/v3/api/file/{filepath}", svc.hand.DeleteFile) + svc.rout.Get("/v3/api/files/{filepath}", svc.hand.ListFiles) selector := svc.rout.Selector() for _, item := range selector.Routes { diff --git a/app/storage/storage.go b/app/storage/storage.go index b4e92e3..1f33c9f 100644 --- a/app/storage/storage.go +++ b/app/storage/storage.go @@ -25,11 +25,34 @@ func NewStorage(basepath string) *Storage { return res } +const filesubdir = "files" +const tmpsubdir = "tmps" + +func (store *Storage) makeCollecionpath(collection string) string { + return filepath.Join(store.basepath, filesubdir, collection) +} + +func (store *Storage) makeFilepath(collection, filename string) string { + return filepath.Join(store.basepath, filesubdir, collection, filename) +} + +func (store *Storage) makeTmppath(tmpname string) string { + return filepath.Join(store.basepath, tmpsubdir, tmpname) +} + +func (store *Storage) makeTmpsubdir() string { + return filepath.Join(store.basepath, tmpsubdir) +} + +func (store *Storage) makeFilesubdir(collection, filename string) string { + return filepath.Join(store.basepath, filesubdir) +} + func (store *Storage) GetFileReader(collection, filename string) (io.ReadCloser, error) { var err error var res io.ReadCloser - filename = filepath.Join(store.basepath, collection, filename) + filename = store.makeFilepath(collection, filename) file, err := os.OpenFile(filename, os.O_RDONLY, 0) if err != nil { return res, err @@ -40,15 +63,16 @@ func (store *Storage) GetFileReader(collection, filename string) (io.ReadCloser, func (store *Storage) HardlinkFile(tmpname, collection, filename string) error { var err error - dirname := filepath.Join(store.basepath, collection) + dirname := store.makeCollecionpath(collection) err = os.MkdirAll(dirname, 0750) if err != nil { return err } - filename = filepath.Join(store.basepath, collection, filename) + filename = store.makeFilepath(collection, filename) os.Remove(filename) // TODO + tmpname = store.makeTmppath(tmpname) err = os.Link(tmpname, filename) if err != nil { return err @@ -67,11 +91,17 @@ func (store *Storage) WriteTempFile(source io.Reader) (string, int64, string, er tmpname := auxuuid.NewUUID() tmpname = fmt.Sprintf("file-%s.tmp", tmpname) - tmppath := filepath.Join(store.basepath, tmpname) + tmppath := store.makeTmppath(tmpname) + + tmpdirpath := store.makeTmpsubdir() + err = os.MkdirAll(tmpdirpath, 0750) + if err != nil { + return tmpname, size, digest, err + } file, err := os.OpenFile(tmppath, os.O_WRONLY|os.O_CREATE, 0640) if err != nil { - return tmppath, size, digest, err + return tmpname, size, digest, err } defer file.Close() @@ -80,23 +110,25 @@ func (store *Storage) WriteTempFile(source io.Reader) (string, int64, string, er size, err = io.Copy(writer, source) if err != nil { - return tmppath, size, digest, err + return tmpname, size, digest, err } digest = hex.EncodeToString(hasher.Sum(nil)) digest = fmt.Sprintf("sha256:%s", digest) - return tmppath, size, digest, err + return tmpname, size, digest, err } func (store *Storage) DeleteFile(collection, filename string) error { var err error - filename = filepath.Join(store.basepath, collection, filename) + filename = store.makeFilepath(collection, filename) err = os.Remove(filename) if err != nil { return err } - dirname := filepath.Join(store.basepath, collection) + // TODO: more safe removing + dirname := store.makeCollecionpath(collection) + err = os.RemoveAll(dirname) if err != nil { return err diff --git a/pkg/client/cliaux.go b/pkg/client/cliaux.go new file mode 100644 index 0000000..979942f --- /dev/null +++ b/pkg/client/cliaux.go @@ -0,0 +1,48 @@ +package client + +import ( + "encoding/base64" + "net/url" + "path" + "strings" +) + +const fileAPI = "/v3/api/file/" +const serviceAPI = "/v3/api/service/" + +func createBasicAuthPair(username, password string) string { + auth := username + ":" + password + return "Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) +} + +func convertFileLink(ref string) (string, error) { + var err error + var res string + if !strings.Contains(ref, "://") { + ref = "https://" + ref + } + url, err := url.Parse(ref) + if err != nil { + return res, err + } + url.Path = path.Join(fileAPI, url.Path) + url.User = nil + res = url.String() + return res, err +} + +func convertServiceLink(ref string) (string, error) { + var err error + var res string + if !strings.Contains(ref, "://") { + ref = "https://" + ref + } + url, err := url.Parse(ref) + if err != nil { + return res, err + } + url.Path = path.Join(serviceAPI, url.Path) + url.User = nil + res = url.String() + return res, err +} diff --git a/pkg/client/client.go b/pkg/client/client.go index a5cd061..173e83d 100644 --- a/pkg/client/client.go +++ b/pkg/client/client.go @@ -3,20 +3,14 @@ package client import ( "context" "crypto/tls" - "encoding/base64" "fmt" "io" "net/http" - "net/url" "os" - "path" "path/filepath" - "strings" + "strconv" ) -const fileAPI = "/v3/api/file/" -const serviceAPI = "/v3/api/service/" - type Client struct{} func NewClient() *Client { @@ -31,7 +25,7 @@ func (cli *Client) ServiceHello(ctx context.Context, ref string) (bool, error) { if err != nil { return res, err } - req, err := http.NewRequestWithContext(ctx, "GET", ref, nil) + req, err := http.NewRequestWithContext(ctx, http.MethodGet, ref, nil) if err != nil { return res, err } @@ -63,7 +57,7 @@ func (cli *Client) FileExists(ctx context.Context, ref string) (bool, error) { if err != nil { return res, err } - req, err := http.NewRequestWithContext(ctx, "HEAD", ref, nil) + req, err := http.NewRequestWithContext(ctx, http.MethodHead, ref, nil) if err != nil { return res, err } @@ -87,43 +81,6 @@ func (cli *Client) FileExists(ctx context.Context, ref string) (bool, error) { return res, err } -func createBasicAuthPair(username, password string) string { - auth := username + ":" + password - return "Basic " + base64.StdEncoding.EncodeToString([]byte(auth)) -} - -func convertFileLink(ref string) (string, error) { - var err error - var res string - if !strings.Contains(ref, "://") { - ref = "https://" + ref - } - url, err := url.Parse(ref) - if err != nil { - return res, err - } - url.Path = path.Join(fileAPI, url.Path) - url.User = nil - res = url.String() - return res, err -} - -func convertServiceLink(ref string) (string, error) { - var err error - var res string - if !strings.Contains(ref, "://") { - ref = "https://" + ref - } - url, err := url.Parse(ref) - if err != nil { - return res, err - } - url.Path = path.Join(serviceAPI, url.Path) - url.User = nil - res = url.String() - return res, err -} - func (cli *Client) GetFile(ctx context.Context, ref, filename string) error { var err error ref, err = convertFileLink(ref) @@ -131,7 +88,7 @@ func (cli *Client) GetFile(ctx context.Context, ref, filename string) error { return err } - req, err := http.NewRequestWithContext(ctx, "GET", ref, nil) + req, err := http.NewRequestWithContext(ctx, http.MethodGet, ref, nil) if err != nil { return err } @@ -150,7 +107,7 @@ func (cli *Client) GetFile(ctx context.Context, ref, filename string) error { defer resp.Body.Close() if resp.StatusCode != http.StatusOK { - err := fmt.Errorf("Received wrong status code: %s", resp.StatusCode) + err := fmt.Errorf("Received wrong status code: %s", resp.Status) return err } @@ -169,3 +126,80 @@ func (cli *Client) GetFile(ctx context.Context, ref, filename string) error { } return err } + +func (cli *Client) PutFile(ctx context.Context, filename, ref string) error { + var err error + ref, err = convertFileLink(ref) + if err != nil { + return err + } + file, err := os.Open(filename) + if err != nil { + return err + } + defer file.Close() + + req, err := http.NewRequestWithContext(ctx, http.MethodPut, ref, file) + if err != nil { + return err + } + transport := &http.Transport{ + TLSClientConfig: &tls.Config{ + InsecureSkipVerify: true, + }, + } + client := &http.Client{ + Transport: transport, + } + fileinfo, err := os.Stat(filename) + if err != nil { + return err + } + filesize := fileinfo.Size() + + req.Header.Set("Content-Type", "application/octet-stream") + req.Header.Set("Content-Size", strconv.FormatInt(filesize, 10)) + + resp, err := client.Do(req) + if err != nil { + return err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + err := fmt.Errorf("Received wrong status code: %s", resp.Status) + return err + } + return err +} + +func (cli *Client) DeleteFile(ctx context.Context, ref, filename string) error { + var err error + ref, err = convertFileLink(ref) + if err != nil { + return err + } + req, err := http.NewRequestWithContext(ctx, http.MethodDelete, ref, nil) + if err != nil { + return err + } + transport := &http.Transport{ + TLSClientConfig: &tls.Config{ + InsecureSkipVerify: true, + }, + } + client := &http.Client{ + Transport: transport, + } + resp, err := client.Do(req) + if err != nil { + return err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + err := fmt.Errorf("Received wrong status code: %s", resp.Status) + return err + } + return err +} diff --git a/pkg/client/client_test.go b/pkg/client/client_test.go new file mode 100644 index 0000000..d3cc787 --- /dev/null +++ b/pkg/client/client_test.go @@ -0,0 +1,89 @@ +package client + +import ( + "context" + "fmt" + "math/rand" + "os" + "path/filepath" + "sync" + "testing" + "time" + + //"mstore/pkg/client" + "mstore/app/server" + + "github.com/stretchr/testify/require" +) + +func TestService(t *testing.T) { + var srvport int64 = 10250 + srvdir := t.TempDir() + srvaddr := fmt.Sprintf("127.0.0.1:%d", srvport) + + srv, err := server.NewServer() + require.NoError(t, err) + { + err = srv.Configure() + require.NoError(t, err) + + srv.SetDatadir(srvdir) + srv.SetLogdir(srvdir) + srv.SetRundir(srvdir) + srv.SetPort(srvport) + + err = srv.Build() + require.NoError(t, err) + + var svcWG sync.WaitGroup + errPipe := make(chan error, 5) + + startFunc := func() { + err := srv.Service().Run() + errPipe <- err + svcWG.Done() + } + + stopFunc := func() { + srv.Service().Stop() + svcWG.Wait() + err = <-errPipe + require.NoError(t, err) + } + defer stopFunc() + + svcWG.Add(1) + go startFunc() + time.Sleep(1 * time.Second) + } + { + fmt.Printf("=== ServiceHello ===\n") + cli := NewClient() + ctx := context.Background() + ctx, _ = context.WithTimeout(ctx, 1*time.Second) + + helloRes, err := cli.ServiceHello(ctx, srvaddr+"/hello") + require.NoError(t, err) + require.True(t, helloRes) + } + { + tmpdir := t.TempDir() + tmpfile := filepath.Join(tmpdir, "foo.bin") + + filedata := make([]byte, 32) + _, err = rand.Read(filedata) + require.NoError(t, err) + + err := os.WriteFile(tmpfile, filedata, 0666) + require.NoError(t, err) + + fmt.Printf("=== PutFile ===\n") + cli := NewClient() + ctx := context.Background() + ctx, _ = context.WithTimeout(ctx, 1*time.Second) + + err = cli.PutFile(ctx, tmpfile, srvaddr+"/foo.bin") + require.NoError(t, err) + + } +} diff --git a/test/file_test.go b/test/file_test.go index d8fb81e..b1c4fc8 100644 --- a/test/file_test.go +++ b/test/file_test.go @@ -10,26 +10,29 @@ import ( "math/rand" "net/http" "net/http/httptest" + "path/filepath" "testing" "mstore/app/router" "mstore/app/server" ) -func xxxTestFileOperations(t *testing.T) { +func TestFileOperations(t *testing.T) { var err error fmt.Printf("=== MakeServer ===\n") srv, err := server.NewServer() require.NoError(t, err) + filename := `bare.bin` + { err = srv.Configure() require.NoError(t, err) - tmpdir := t.TempDir() - srv.SetDatadir(tmpdir) - srv.SetLogdir(tmpdir) - srv.SetRundir(tmpdir) + //tmpdir := t.TempDir() + //srv.SetDatadir(tmpdir) + //srv.SetLogdir(tmpdir) + //srv.SetRundir(tmpdir) err = srv.Build() require.NoError(t, err) @@ -37,7 +40,7 @@ func xxxTestFileOperations(t *testing.T) { { fmt.Printf("=== PutFile ===\n") - reqPath := `/v3/api/file/foo/bare` + reqPath := `/v3/api/file/` + filename routePath := `/v3/api/file/{filepath}` rout := router.NewRouter() @@ -46,19 +49,20 @@ func xxxTestFileOperations(t *testing.T) { rout.Put(routePath, hand.PutFile) - datasize := 16 + datasize := 64 filedata := make([]byte, datasize) _, err = rand.Read(filedata) require.NoError(t, err) filedata = []byte(hex.EncodeToString(filedata)) + datasize *= 2 source := bytes.NewReader(filedata) request, err := http.NewRequest("PUT", reqPath, source) require.NoError(t, err) - request.Header.Set("Content-Length", fmt.Sprintf("%d", datasize)) + request.Header.Set("Content-Size", fmt.Sprintf("%d", datasize)) request.Header.Set("Content-Type", "application/octet-stream") recorder := httptest.NewRecorder() @@ -75,7 +79,7 @@ func xxxTestFileOperations(t *testing.T) { { fmt.Printf("=== FileExists ===\n") - reqPath := `/v3/api/file/foo/bare` + reqPath := filepath.Join(`/v3/api/file`, filename) routePath := `/v3/api/file/{filepath}` rout := router.NewRouter() @@ -100,7 +104,7 @@ func xxxTestFileOperations(t *testing.T) { } { fmt.Printf("=== GetFile ===\n") - reqPath := `/v3/api/file/foo/bare` + reqPath := filepath.Join(`/v3/api/file`, filename) routePath := `/v3/api/file/{filepath}` rout := router.NewRouter() @@ -123,9 +127,10 @@ func xxxTestFileOperations(t *testing.T) { fmt.Printf("Response body: %s\n", string(bodyBytes)) } + return { fmt.Printf("=== DeleteFile ===\n") - reqPath := `/v3/api/file/foo/bare` + reqPath := filepath.Join(`/v3/api/file`, filename) routePath := `/v3/api/file/{filepath}` rout := router.NewRouter() @@ -152,7 +157,7 @@ func xxxTestFileOperations(t *testing.T) { { fmt.Printf("=== FileNotExists ===\n") - reqPath := `/v3/api/file/foo/bare` + reqPath := filepath.Join(`/v3/api/file`, filename) routePath := `/v3/api/file/{filepath}` rout := router.NewRouter() diff --git a/test/server_test.go b/test/server_test.go index 529fa1e..6cda40a 100644 --- a/test/server_test.go +++ b/test/server_test.go @@ -9,14 +9,13 @@ import ( "testing" "time" - "mstore/pkg/client" "mstore/app/server" - + "mstore/pkg/client" "github.com/stretchr/testify/require" ) -func TestService(t *testing.T) { +func xxxTestService(t *testing.T) { var srvport int64 = 10250 srvdir := t.TempDir() srvaddr := fmt.Sprintf("127.0.0.1:%d", srvport) @@ -74,13 +73,13 @@ func TestService(t *testing.T) { err := os.WriteFile(tmpfile, filedata, 0666) require.NoError(t, err) - //fmt.Printf("=== PutFile ===\n") - //cli := client.NewClient() - //ctx := context.Background() - //ctx, _ = context.WithTimeout(ctx, 1*time.Second) + fmt.Printf("=== PutFile ===\n") + cli := client.NewClient() + ctx := context.Background() + ctx, _ = context.WithTimeout(ctx, 1*time.Second) - //err = cli.PutFile(ctx, tmpfile, srvaddr+"/foo.bin") - //require.NoError(t, err) + err = cli.PutFile(ctx, tmpfile, srvaddr+"/foo.bin") + require.NoError(t, err) } }