github-mirror/rclone
2
0
Fork 0
mirror of https://github.com/rclone/rclone.git synced 2024-11-24 20:56:20 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

backend: add Linkbox backend

Browse Source 
Add backend for linkbox.io with read and write capabilities

fixes #6960 #6629
This commit is contained in:
viktor 2023-10-20 15:35:56 +04:00 committed by Nick Craig-Wood
parent 168d577297
commit a466ababd0
11 changed files with 1011 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -53,6 +53,7 @@ Rclone *("rsync for cloud storage")* is a command-line program to sync files and
* Koofr [:page_facing_up:](https://rclone.org/koofr/)
* Leviia Object Storage [:page_facing_up:](https://rclone.org/s3/#leviia)
* Liara Object Storage [:page_facing_up:](https://rclone.org/s3/#liara-object-storage)
* Linkbox [:page_facing_up:](https://rclone.org/linkbox)
* Linode Object Storage [:page_facing_up:](https://rclone.org/s3/#linode)
* Mail.ru Cloud [:page_facing_up:](https://rclone.org/mailru/)
* Memset Memstore [:page_facing_up:](https://rclone.org/swift/)

1
backend/all/all.go
View File

@ -28,6 +28,7 @@ import (
_ "github.com/rclone/rclone/backend/internetarchive"
_ "github.com/rclone/rclone/backend/jottacloud"
_ "github.com/rclone/rclone/backend/koofr"
_ "github.com/rclone/rclone/backend/linkbox"
_ "github.com/rclone/rclone/backend/local"
_ "github.com/rclone/rclone/backend/mailru"
_ "github.com/rclone/rclone/backend/mega"

906
backend/linkbox/linkbox.go Normal file
View File

@ -0,0 +1,906 @@
// Package linkbox provides an interface to the linkbox.to Cloud storage system.
package linkbox
import (
"bytes"
"context"
"crypto/md5"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"path"
"strconv"
"strings"
"time"
"github.com/rclone/rclone/fs"
"github.com/rclone/rclone/fs/config/configmap"
"github.com/rclone/rclone/fs/config/configstruct"
"github.com/rclone/rclone/fs/fserrors"
"github.com/rclone/rclone/fs/fshttp"
"github.com/rclone/rclone/fs/hash"
"github.com/rclone/rclone/lib/pacer"
"github.com/rclone/rclone/lib/rest"
)
const (
retriesAmmount = 2
maxEntitiesPerPage = 64
minSleep = 200 * time.Millisecond
maxSleep = 2 * time.Second
pacerBurst = 1
linkboxAPIURL = "https://www.linkbox.to/api/open/"
)
func init() {
fsi := &fs.RegInfo{
Name: "linkbox",
Description: "Linkbox",
NewFs: NewFs,
Options: []fs.Option{{
Name: "token",
Help: "Token from https://www.linkbox.to/admin/account",
Sensitive: true,
Required: true,
}},
}
fs.Register(fsi)
}
// Options defines the configuration for this backend
type Options struct {
Token string `config:"token"`
}
// Fs stores the interface to the remote Linkbox files
type Fs struct {
name string
root string
opt Options // options for this backend
features *fs.Features // optional features
ci *fs.ConfigInfo // global config
srv *rest.Client // the connection to the server
pacer *fs.Pacer
}
// Object is a remote object that has been stat'd (so it exists, but is not necessarily open for reading)
type Object struct {
fs *Fs
remote string
size int64
modTime time.Time
contentType string
fullURL string
pid int
isDir bool
id string
}
// NewFs creates a new Fs object from the name and root. It connects to
// the host specified in the config file.
func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) {
// Parse config into Options struct
opt := new(Options)
err := configstruct.Set(m, opt)
if err != nil {
return nil, err
}
ci := fs.GetConfig(ctx)
f := &Fs{
name: name,
opt: *opt,
ci: ci,
srv: rest.NewClient(fshttp.NewClient(ctx)),
pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep))),
}
f.pacer.SetRetries(retriesAmmount)
f.features = (&fs.Features{
CanHaveEmptyDirectories: true,
CaseInsensitive: true,
}).Fill(ctx, f)
// Check to see if the root actually an existing file
remote := path.Base(root)
f.root = path.Dir(root)
if f.root == "." {
f.root = ""
}
_, err = f.NewObject(ctx, remote)
if err != nil {
if errors.Is(err, fs.ErrorObjectNotFound) || errors.Is(err, fs.ErrorNotAFile) || errors.Is(err, fs.ErrorIsDir) {
// File doesn't exist so return old f
f.root = root
return f, nil
}
return nil, err
}
// return an error with an fs which points to the parent
return f, fs.ErrorIsFile
}
type entity struct {
Type string `json:"type"`
Name string `json:"name"`
URL string `json:"url"`
Ctime int64 `json:"ctime"`
Size int `json:"size"`
ID int `json:"id"`
Pid int `json:"pid"`
ItemID string `json:"item_id"`
}
type data struct {
Entities []entity `json:"list"`
}
type fileSearchRes struct {
SearchData data `json:"data"`
Status int `json:"status"`
Message string `json:"msg"`
}
func (f *Fs) getIDByDir(ctx context.Context, dir string) (int, error) {
var pid int
var err error
err = f.pacer.Call(func() (bool, error) {
pid, err = f._getIDByDir(ctx, dir)
return f.shouldRetry(ctx, err)
})
if fserrors.IsRetryError(err) {
fs.Debugf(f, "getting ID of Dir error: retrying: pid = {%d}, dir = {%s}, err = {%s}", pid, dir, err)
err = fs.ErrorDirNotFound
}
return pid, err
}
func (f *Fs) _getIDByDir(ctx context.Context, dir string) (int, error) {
if dir == "" || dir == "/" {
return 0, nil // we assume that it is root directory
}
path := strings.TrimPrefix(dir, "/")
dirs := strings.Split(path, "/")
pid := 0
for level, tdir := range dirs {
pageNumber := 0
numberOfEntities := maxEntitiesPerPage
for numberOfEntities == maxEntitiesPerPage {
pageNumber++
opts := makeSearchQuery("", pid, f.opt.Token, pageNumber)
responseResult := fileSearchRes{}
err := getUnmarshaledResponse(ctx, f, opts, &responseResult)
if err != nil {
return 0, fmt.Errorf("error in unmurshaling response from linkbox.to: %w", err)
}
numberOfEntities = len(responseResult.SearchData.Entities)
if len(responseResult.SearchData.Entities) == 0 {
return 0, fs.ErrorDirNotFound
}
for _, entity := range responseResult.SearchData.Entities {
if entity.Pid == pid && (entity.Type == "dir" || entity.Type == "sdir") && strings.EqualFold(entity.Name, tdir) {
pid = entity.ID
if level == len(dirs)-1 {
return pid, nil
}
}
}
if pageNumber > 100000 {
return 0, fmt.Errorf("too many results")
}
}
}
// fs.Debugf(f, "getIDByDir fs.ErrorDirNotFound dir = {%s} path = {%s}", dir, path)
return 0, fs.ErrorDirNotFound
}
func getUnmarshaledResponse(ctx context.Context, f *Fs, opts *rest.Opts, result interface{}) error {
err := f.pacer.Call(func() (bool, error) {
_, err := f.srv.CallJSON(ctx, opts, nil, &result)
return f.shouldRetry(ctx, err)
})
return err
}
func makeSearchQuery(name string, pid int, token string, pageNubmer int) *rest.Opts {
return &rest.Opts{
Method: "GET",
RootURL: linkboxAPIURL,
Path: "file_search",
Parameters: url.Values{
"token": {token},
"name": {name},
"pid": {strconv.Itoa(pid)},
"pageNo": {strconv.Itoa(pageNubmer)},
"pageSize": {strconv.Itoa(maxEntitiesPerPage)},
},
}
}
func (f *Fs) getFilesByDir(ctx context.Context, dir string) ([]*Object, error) {
var responseResult fileSearchRes
var files []*Object
var numberOfEntities int
fullPath := path.Join(f.root, dir)
fullPath = strings.TrimPrefix(fullPath, "/")
pid, err := f.getIDByDir(ctx, fullPath)
if err != nil {
fs.Debugf(f, "getting files list error: dir = {%s} fullPath = {%s} pid = {%d} err = {%s}", dir, fullPath, pid, err)
return nil, err
}
pageNumber := 0
numberOfEntities = maxEntitiesPerPage
for numberOfEntities == maxEntitiesPerPage {
pageNumber++
opts := makeSearchQuery("", pid, f.opt.Token, pageNumber)
responseResult = fileSearchRes{}
err = getUnmarshaledResponse(ctx, f, opts, &responseResult)
if err != nil {
return nil, fmt.Errorf("getting files failed with error in unmurshaling response from linkbox.to: %w", err)
}
if responseResult.Status != 1 {
return nil, fmt.Errorf("parsing failed: %s", responseResult.Message)
}
numberOfEntities = len(responseResult.SearchData.Entities)
for _, entity := range responseResult.SearchData.Entities {
if entity.Pid != pid {
fs.Debugf(f, "getFilesByDir error with entity.Name {%s} dir {%s}", entity.Name, dir)
}
file := &Object{
fs: f,
remote: entity.Name,
modTime: time.Unix(entity.Ctime, 0),
contentType: entity.Type,
size: int64(entity.Size),
fullURL: entity.URL,
isDir: entity.Type == "dir" || entity.Type == "sdir",
id: entity.ItemID,
pid: entity.Pid,
}
files = append(files, file)
}
if pageNumber > 100000 {
return files, fmt.Errorf("too many results")
}
}
return files, nil
}
func splitDirAndName(remote string) (dir string, name string) {
lastSlashPosition := strings.LastIndex(remote, "/")
if lastSlashPosition == -1 {
dir = ""
name = remote
} else {
dir = remote[:lastSlashPosition]
name = remote[lastSlashPosition+1:]
}
// fs.Debugf(nil, "splitDirAndName remote = {%s}, dir = {%s}, name = {%s}", remote, dir, name)
return dir, name
}
// List the objects and directories in dir into entries. The
// entries can be returned in any order but should be for a
// complete directory.
//
// dir should be "" to list the root, and should not have
// trailing slashes.
//
// This should return ErrDirNotFound if the directory isn't
// found.
func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) {
// fs.Debugf(f, "List method dir = {%s}", dir)
objects, err := f.getFilesByDir(ctx, dir)
if err != nil {
return nil, err
}
for _, obj := range objects {
prefix := ""
if dir != "" {
prefix = dir + "/"
}
if obj.isDir {
entries = append(entries, fs.NewDir(prefix+obj.remote, obj.modTime))
} else {
obj.remote = prefix + obj.remote
entries = append(entries, obj)
}
}
return entries, nil
}
func getObject(ctx context.Context, f *Fs, name string, pid int, token string) (entity, error) {
var err error
var entity entity
err = f.pacer.Call(func() (bool, error) {
entity, err = _getObject(ctx, f, name, pid, token)
return f.shouldRetry(ctx, err)
})
// fs.Debugf(f, "getObject: name = {%s}, pid = {%d}, err = {%#v}", name, pid, err)
if fserrors.IsRetryError(err) {
fs.Debugf(f, "getObject IsRetryError: name = {%s}, pid = {%d}, err = {%#v}", name, pid, err)
err = fs.ErrorObjectNotFound
}
return entity, err
}
func _getObject(ctx context.Context, f *Fs, name string, pid int, token string) (entity, error) {
pageNumber := 0
numberOfEntities := maxEntitiesPerPage
for numberOfEntities == maxEntitiesPerPage {
pageNumber++
opts := makeSearchQuery("", pid, token, pageNumber)
searchResponse := fileSearchRes{}
err := getUnmarshaledResponse(ctx, f, opts, &searchResponse)
if err != nil {
return entity{}, fmt.Errorf("unable to create new object: %w", err)
}
if searchResponse.Status != 1 {
return entity{}, fmt.Errorf("unable to create new object: %s", searchResponse.Message)
}
numberOfEntities = len(searchResponse.SearchData.Entities)
// fs.Debugf(f, "getObject numberOfEntities {%d} name {%s}", numberOfEntities, name)
for _, obj := range searchResponse.SearchData.Entities {
// fs.Debugf(f, "getObject entity.Name {%s} name {%s}", obj.Name, name)
if obj.Pid == pid && strings.EqualFold(obj.Name, name) {
// fs.Debugf(f, "getObject found entity.Name {%s} name {%s}", obj.Name, name)
if obj.Type == "dir" || obj.Type == "sdir" {
return entity{}, fs.ErrorIsDir
}
return obj, nil
}
}
if pageNumber > 100000 {
return entity{}, fmt.Errorf("too many results")
}
}
return entity{}, fs.ErrorObjectNotFound
}
// NewObject finds the Object at remote. If it can't be found
// it returns the error ErrorObjectNotFound.
//
// If remote points to a directory then it should return
// ErrorIsDir if possible without doing any extra work,
// otherwise ErrorObjectNotFound.
func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) {
var newObject entity
var dir, name string
fullPath := path.Join(f.root, remote)
dir, name = splitDirAndName(fullPath)
dirID, err := f.getIDByDir(ctx, dir)
if err != nil {
return nil, fs.ErrorObjectNotFound
}
newObject, err = getObject(ctx, f, name, dirID, f.opt.Token)
if err != nil {
// fs.Debugf(f, "NewObject getObject error = {%s}", err)
return nil, err
}
if newObject == (entity{}) {
return nil, fs.ErrorObjectNotFound
}
return &Object{
fs: f,
remote: name,
modTime: time.Unix(newObject.Ctime, 0),
fullURL: newObject.URL,
size: int64(newObject.Size),
id: newObject.ItemID,
pid: newObject.Pid,
}, nil
}
// Mkdir makes the directory (container, bucket)
//
// Shouldn't return an error if it already exists
func (f *Fs) Mkdir(ctx context.Context, dir string) error {
var pdir, name string
fullPath := path.Join(f.root, dir)
if fullPath == "" {
return nil
}
fullPath = strings.TrimPrefix(fullPath, "/")
dirs := strings.Split(fullPath, "/")
dirs = append([]string{""}, dirs...)
for i, dirName := range dirs {
pdir = path.Join(pdir, dirName)
name = dirs[i+1]
pid, err := f.getIDByDir(ctx, pdir)
if err != nil {
return err
}
opts := &rest.Opts{
Method: "GET",
RootURL: linkboxAPIURL,
Path: "folder_create",
Parameters: url.Values{
"token": {f.opt.Token},
"name": {name},
"pid": {strconv.Itoa(pid)},
"isShare": {"0"},
"canInvite": {"1"},
"canShare": {"1"},
"withBodyImg": {"1"},
"desc": {""},
},
}
response := getResponse{}
err = getUnmarshaledResponse(ctx, f, opts, &response)
if err != nil {
return fmt.Errorf("Mkdir error in unmurshaling response from linkbox.to: %w", err)
}
if i+1 == len(dirs)-1 {
break
}
// response status 1501 means that directory already exists
if response.Status != 1 && response.Status != 1501 {
return fmt.Errorf("could not create dir[%s]: %s", dir, response.Message)
}
}
return nil
}
func (f *Fs) purgeCheck(ctx context.Context, dir string, check bool) error {
fullPath := path.Join(f.root, dir)
if fullPath == "" {
return fs.ErrorDirNotFound
}
fullPath = strings.TrimPrefix(fullPath, "/")
dirIDs, err := f.getIDByDir(ctx, fullPath)
if err != nil {
return err
}
entries, err := f.List(ctx, dir)
if err != nil {
return err
}
if len(entries) != 0 && check {
return fs.ErrorDirectoryNotEmpty
}
opts := &rest.Opts{
Method: "GET",
RootURL: linkboxAPIURL,
Path: "folder_del",
Parameters: url.Values{
"token": {f.opt.Token},
"dirIds": {strconv.Itoa(dirIDs)},
},
}
response := getResponse{}
err = getUnmarshaledResponse(ctx, f, opts, &response)
if err != nil {
return fmt.Errorf("purging error in unmurshaling response from linkbox.to: %w", err)
}
if response.Status != 1 {
// it can be some different error, but Linkbox
// returns very few statuses
return fs.ErrorDirExists
}
return nil
}
// Rmdir removes the directory (container, bucket) if empty
//
// Return an error if it doesn't exist or isn't empty
func (f *Fs) Rmdir(ctx context.Context, dir string) error {
return f.purgeCheck(ctx, dir, true)
}
// SetModTime sets modTime on a particular file
func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error {
return fs.ErrorCantSetModTime
}
// Open opens the file for read. Call Close() on the returned io.ReadCloser
func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) {
var res *http.Response
downloadURL := o.fullURL
if downloadURL == "" {
_, name := splitDirAndName(o.Remote())
newObject, err := getObject(ctx, o.fs, name, o.pid, o.fs.opt.Token)
if err != nil {
return nil, err
}
if newObject == (entity{}) {
// fs.Debugf(o.fs, "Open entity is empty: name = {%s}", name)
return nil, fs.ErrorObjectNotFound
}
downloadURL = newObject.URL
}
opts := &rest.Opts{
Method: "GET",
RootURL: downloadURL,
Options: options,
}
err := o.fs.pacer.Call(func() (bool, error) {
var err error
res, err = o.fs.srv.Call(ctx, opts)
return o.fs.shouldRetry(ctx, err)
})
if err != nil {
return nil, fmt.Errorf("Open failed: %w", err)
}
return res.Body, nil
}
// Update in to the object with the modTime given of the given size
//
// When called from outside an Fs by rclone, src.Size() will always be >= 0.
// But for unknown-sized objects (indicated by src.Size() == -1), Upload should either
// return an error or update the object properly (rather than e.g. calling panic).
func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error {
if src.Size() == 0 {
return fs.ErrorCantUploadEmptyFiles
}
remote := o.Remote()
tmpObject, err := o.fs.NewObject(ctx, remote)
if err == nil {
// fs.Debugf(o.fs, "Update: removing old file")
_ = tmpObject.Remove(ctx)
}
first10m := io.LimitReader(in, 10_485_760)
first10mBytes, err := io.ReadAll(first10m)
if err != nil {
return fmt.Errorf("Update err in reading file: %w", err)
}
// get upload authorization (step 1)
opts := &rest.Opts{
Method: "GET",
RootURL: linkboxAPIURL,
Path: "get_upload_url",
Options: options,
Parameters: url.Values{
"token": {o.fs.opt.Token},
"fileMd5ofPre10m": {fmt.Sprintf("%x", md5.Sum(first10mBytes))},
"fileSize": {strconv.FormatInt(src.Size(), 10)},
},
}
getFistStepResult := getUploadURLResponse{}
err = getUnmarshaledResponse(ctx, o.fs, opts, &getFistStepResult)
if err != nil {
return fmt.Errorf("Update err in unmarshaling response: %w", err)
}
switch getFistStepResult.Status {
case 1:
// upload file using link from first step
var res *http.Response
file := io.MultiReader(bytes.NewReader(first10mBytes), in)
opts := &rest.Opts{
Method: "PUT",
RootURL: getFistStepResult.Data.SignURL,
Options: options,
Body: file,
}
err = o.fs.pacer.CallNoRetry(func() (bool, error) {
res, err = o.fs.srv.Call(ctx, opts)
return o.fs.shouldRetry(ctx, err)
})
if err != nil {
return fmt.Errorf("update err in uploading file: %w", err)
}
_, err = io.ReadAll(res.Body)
if err != nil {
return fmt.Errorf("update err in reading response: %w", err)
}
case 600:
// Status means that we don't need to upload file
// We need only to make second step
default:
return fmt.Errorf("got unexpected message from Linkbox: %s", getFistStepResult.Message)
}
fullPath := path.Join(o.fs.root, remote)
fullPath = strings.TrimPrefix(fullPath, "/")
pdir, name := splitDirAndName(fullPath)
pid, err := o.fs.getIDByDir(ctx, pdir)
if err != nil {
return err
}
// create file item at Linkbox (second step)
opts = &rest.Opts{
Method: "GET",
RootURL: linkboxAPIURL,
Path: "folder_upload_file",
Options: options,
Parameters: url.Values{
"token": {o.fs.opt.Token},
"fileMd5ofPre10m": {fmt.Sprintf("%x", md5.Sum(first10mBytes))},
"fileSize": {strconv.FormatInt(src.Size(), 10)},
"pid": {strconv.Itoa(pid)},
"diyName": {name},
},
}
getSecondStepResult := getUploadURLResponse{}
err = getUnmarshaledResponse(ctx, o.fs, opts, &getSecondStepResult)
if err != nil {
return fmt.Errorf("Update err in unmarshaling response: %w", err)
}
if getSecondStepResult.Status != 1 {
return fmt.Errorf("get bad status from linkbox: %s", getSecondStepResult.Message)
}
newObject, err := getObject(ctx, o.fs, name, pid, o.fs.opt.Token)
if err != nil {
return fs.ErrorObjectNotFound
}
if newObject == (entity{}) {
return fs.ErrorObjectNotFound
}
o.pid = pid
o.remote = remote
o.modTime = time.Unix(newObject.Ctime, 0)
o.size = src.Size()
return nil
}
// Remove this object
func (o *Object) Remove(ctx context.Context) error {
opts := &rest.Opts{
Method: "GET",
RootURL: linkboxAPIURL,
Path: "file_del",
Parameters: url.Values{
"token": {o.fs.opt.Token},
"itemIds": {o.id},
},
}
requestResult := getUploadURLResponse{}
err := getUnmarshaledResponse(ctx, o.fs, opts, &requestResult)
if err != nil {
return fmt.Errorf("could not Remove: %w", err)
}
if requestResult.Status != 1 {
return fmt.Errorf("got unexpected message from Linkbox: %s", requestResult.Message)
}
return nil
}
// ModTime returns the modification time of the remote http file
func (o *Object) ModTime(ctx context.Context) time.Time {
return o.modTime
}
// Remote the name of the remote HTTP file, relative to the fs root
func (o *Object) Remote() string {
return o.remote
}
// Size returns the size in bytes of the remote http file
func (o *Object) Size() int64 {
return o.size
}
// String returns the URL to the remote HTTP file
func (o *Object) String() string {
if o == nil {
return "<nil>"
}
return o.remote
}
// Fs is the filesystem this remote http file object is located within
func (o *Object) Fs() fs.Info {
return o.fs
}
// Hash returns "" since HTTP (in Go or OpenSSH) doesn't support remote calculation of hashes
func (o *Object) Hash(ctx context.Context, r hash.Type) (string, error) {
return "", hash.ErrUnsupported
}
// Storable returns whether the remote http file is a regular file
// (not a directory, symbolic link, block device, character device, named pipe, etc.)
func (o *Object) Storable() bool {
return true
}
// Features returns the optional features of this Fs
// Info provides a read only interface to information about a filesystem.
func (f *Fs) Features() *fs.Features {
return f.features
}
// Name of the remote (as passed into NewFs)
// Name returns the configured name of the file system
func (f *Fs) Name() string {
return f.name
}
// Root of the remote (as passed into NewFs)
func (f *Fs) Root() string {
return f.root
}
// String returns a description of the FS
func (f *Fs) String() string {
return fmt.Sprintf("Linkbox root '%s'", f.root)
}
// Precision of the ModTimes in this Fs
func (f *Fs) Precision() time.Duration {
return fs.ModTimeNotSupported
}
// Hashes returns hash.HashNone to indicate remote hashing is unavailable
// Returns the supported hash types of the filesystem
func (f *Fs) Hashes() hash.Set {
return hash.Set(hash.None)
}
/*
{
"data": {
"signUrl": "http://xx -- Then CURL PUT your file with sign url "
},
"msg": "please use this url to upload (PUT method)",
"status": 1
}
*/
type getResponse struct {
Message string `json:"msg"`
Status int `json:"status"`
}
type getUploadURLData struct {
SignURL string `json:"signUrl"`
}
type getUploadURLResponse struct {
Data getUploadURLData `json:"data"`
getResponse
}
// Put in to the remote path with the modTime given of the given size
//
// When called from outside an Fs by rclone, src.Size() will always be >= 0.
// But for unknown-sized objects (indicated by src.Size() == -1), Put should either
// return an error or upload it properly (rather than e.g. calling panic).
//
// May create the object even if it returns an error - if so
// will return the object and the error, otherwise will return
// nil and the error
func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) {
o := &Object{
fs: f,
remote: src.Remote(),
size: src.Size(),
}
dir, _ := splitDirAndName(src.Remote())
err := f.Mkdir(ctx, dir)
if err != nil {
return nil, err
}
err = o.Update(ctx, in, src, options...)
return o, err
}
// Purge all files in the directory specified
//
// Implement this if you have a way of deleting all the files
// quicker than just running Remove() on the result of List()
//
// Return an error if it doesn't exist
func (f *Fs) Purge(ctx context.Context, dir string) error {
return f.purgeCheck(ctx, dir, false)
}
// shouldRetry determines whether a given err rates being retried
func (f *Fs) shouldRetry(ctx context.Context, err error) (bool, error) {
if err == fs.ErrorDirNotFound {
// fs.Debugf(nil, "retry with %v", err)
return true, err
}
if err == fs.ErrorObjectNotFound {
// fs.Debugf(nil, "retry with %v", err)
return true, err
}
return false, err
}
// Check the interfaces are satisfied
var (
_ fs.Fs = &Fs{}
_ fs.Purger = &Fs{}
_ fs.Object = &Object{}
)

17
backend/linkbox/linkbox_test.go Normal file
View File

@ -0,0 +1,17 @@
// Test Linkbox filesystem interface
package linkbox_test
import (
"testing"
"github.com/rclone/rclone/backend/linkbox"
"github.com/rclone/rclone/fstest/fstests"
)
// TestIntegration runs integration tests against the remote
func TestIntegration(t *testing.T) {
fstests.Run(t, &fstests.Opt{
RemoteName: "TestLinkbox:",
NilObject: (*linkbox.Object)(nil),
})
}

1
bin/make_manual.py
View File

@ -53,6 +53,7 @@ docs = [
"internetarchive.md",
"jottacloud.md",
"koofr.md",
"linkbox.md"
"mailru.md",
"mega.md",
"memory.md",

1
docs/content/_index.md
View File

@ -138,6 +138,7 @@ WebDAV or S3, that work out of the box.)
{{< provider name="Koofr" home="https://koofr.eu/" config="/koofr/" >}}
{{< provider name="Leviia Object Storage" home="https://www.leviia.com/object-storage" config="/s3/#leviia" >}}
{{< provider name="Liara Object Storage" home="https://liara.ir/landing/object-storage" config="/s3/#liara-object-storage" >}}
{{< provider name="Linkbox" home="https://linkbox.to/" config="/linkbox/" >}}
{{< provider name="Linode Object Storage" home="https://www.linode.com/products/object-storage/" config="/s3/#linode" >}}
{{< provider name="Mail.ru Cloud" home="https://cloud.mail.ru/" config="/mailru/" >}}
{{< provider name="Memset Memstore" home="https://www.memset.com/cloud/storage/" config="/swift/" >}}

1
docs/content/docs.md
View File

@ -54,6 +54,7 @@ See the following for detailed instructions for
* [Internet Archive](/internetarchive/)
* [Jottacloud](/jottacloud/)
* [Koofr](/koofr/)
* [Linkbox](/linkbox/)
* [Mail.ru Cloud](/mailru/)
* [Mega](/mega/)
* [Memory](/memory/)

76
docs/content/linkbox.md Normal file
View File

@ -0,0 +1,76 @@
---
title: "Linkbox"
description: "Rclone docs for Linkbox"
versionIntroduced: "v1.65"
---
# {{< icon "fa fa-infinity" >}} Linkbox
Linkbox is [a private cloud drive](https://linkbox.to/).
## Configuration
Here is an example of making a remote for Linkbox.
First run:
rclone config
This will guide you through an interactive setup process:
```
No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
Enter name for new remote.
name> remote
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
XX / Linkbox
\ (linkbox)
Storage> XX
Option token.
Token from https://www.linkbox.to/admin/account
Enter a value.
token> testFromCLToken
Configuration complete.
Options:
- type: linkbox
- token: XXXXXXXXXXX
Keep this "linkbox" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y
```
{{< rem autogenerated options start" - DO NOT EDIT - instead edit fs.RegInfo in backend/linkbox/linkbox.go then run make backenddocs" >}}
### Standard options
Here are the Standard options specific to linkbox (Linkbox).
#### --linkbox-token
Token from https://www.linkbox.to/admin/account
Properties:
- Config: token
- Env Var: RCLONE_LINKBOX_TOKEN
- Type: string
- Required: true
{{< rem autogenerated options stop >}}
## Limitations
Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8),
as they can't be used in JSON strings.

1
docs/content/overview.md
View File

@ -35,6 +35,7 @@ Here is an overview of the major features of each cloud storage system.
| Internet Archive | MD5, SHA1, CRC32 | R/W ¹¹ | No | No | - | RWU |
| Jottacloud | MD5 | R/W | Yes | No | R | RW |
| Koofr | MD5 | - | Yes | No | - | - |
| Linkbox | - | R | No | No | - | - |
| Mail.ru Cloud | Mailru ⁶ | R/W | Yes | No | - | - |
| Mega | - | - | No | Yes | - | - |
| Memory | MD5 | R/W | No | No | - | - |

1
docs/layouts/chrome/navbar.html
View File

@ -77,6 +77,7 @@
<a class="dropdown-item" href="/internetarchive/"><i class="fa fa-archive fa-fw"></i> Internet Archive</a>
<a class="dropdown-item" href="/jottacloud/"><i class="fa fa-cloud fa-fw"></i> Jottacloud</a>
<a class="dropdown-item" href="/koofr/"><i class="fa fa-suitcase fa-fw"></i> Koofr</a>
<a class="dropdown-item" href="/linkbox/"><i class="fa fa-infinity"></i> Linkbox</a>
<a class="dropdown-item" href="/mailru/"><i class="fa fa-at fa-fw"></i> Mail.ru Cloud</a>
<a class="dropdown-item" href="/mega/"><i class="fa fa-archive fa-fw"></i> Mega</a>
<a class="dropdown-item" href="/memory/"><i class="fas fa-memory fa-fw"></i> Memory</a>

5
fstest/test_all/config.yaml
View File

@ -374,6 +374,11 @@ backends:
# - backend: "koofr"
# remote: "TestDigiStorage:"
# fastlist: false
- backend: "linkbox"
remote: "TestLinkbox:"
fastlist: false
ignore:
- TestIntegration/FsMkdir/FsEncoding/invalid_UTF-8
- backend: "premiumizeme"
remote: "TestPremiumizeMe:"
fastlist: false