2017-06-12 17:40:20 +00:00
|
|
|
package lsjson
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2018-03-09 08:44:02 +00:00
|
|
|
"log"
|
2017-06-12 17:40:20 +00:00
|
|
|
"os"
|
|
|
|
"path"
|
|
|
|
"time"
|
|
|
|
|
2018-03-09 08:44:02 +00:00
|
|
|
"github.com/ncw/rclone/backend/crypt"
|
2017-06-12 17:40:20 +00:00
|
|
|
"github.com/ncw/rclone/cmd"
|
2018-01-06 17:00:20 +00:00
|
|
|
"github.com/ncw/rclone/cmd/ls/lshelp"
|
2017-06-12 17:40:20 +00:00
|
|
|
"github.com/ncw/rclone/fs"
|
2018-01-12 16:30:54 +00:00
|
|
|
"github.com/ncw/rclone/fs/operations"
|
|
|
|
"github.com/ncw/rclone/fs/walk"
|
2017-06-12 17:40:20 +00:00
|
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
2018-03-09 08:44:02 +00:00
|
|
|
recurse bool
|
|
|
|
showHash bool
|
|
|
|
showEncrypted bool
|
|
|
|
noModTime bool
|
2017-06-12 17:40:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
cmd.Root.AddCommand(commandDefintion)
|
|
|
|
commandDefintion.Flags().BoolVarP(&recurse, "recursive", "R", false, "Recurse into the listing.")
|
|
|
|
commandDefintion.Flags().BoolVarP(&showHash, "hash", "", false, "Include hashes in the output (may take longer).")
|
|
|
|
commandDefintion.Flags().BoolVarP(&noModTime, "no-modtime", "", false, "Don't read the modification time (can speed things up).")
|
2018-03-09 08:44:02 +00:00
|
|
|
commandDefintion.Flags().BoolVarP(&showEncrypted, "encrypted", "M", false, "Show the encrypted names.")
|
2017-06-12 17:40:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// lsJSON in the struct which gets marshalled for each line
|
|
|
|
type lsJSON struct {
|
2018-03-09 08:44:02 +00:00
|
|
|
Path string
|
|
|
|
Name string
|
|
|
|
Encrypted string `json:",omitempty"`
|
|
|
|
Size int64
|
2018-05-13 09:37:46 +00:00
|
|
|
MimeType string `json:",omitempty"`
|
2018-03-09 08:44:02 +00:00
|
|
|
ModTime Timestamp //`json:",omitempty"`
|
|
|
|
IsDir bool
|
|
|
|
Hashes map[string]string `json:",omitempty"`
|
2018-05-13 08:19:06 +00:00
|
|
|
ID string `json:",omitempty"`
|
2017-06-12 17:40:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Timestamp a time in RFC3339 format with Nanosecond precision secongs
|
|
|
|
type Timestamp time.Time
|
|
|
|
|
|
|
|
// MarshalJSON turns a Timestamp into JSON
|
|
|
|
func (t Timestamp) MarshalJSON() (out []byte, err error) {
|
|
|
|
tt := time.Time(t)
|
|
|
|
if tt.IsZero() {
|
|
|
|
return []byte(`""`), nil
|
|
|
|
}
|
|
|
|
return []byte(`"` + tt.Format(time.RFC3339Nano) + `"`), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var commandDefintion = &cobra.Command{
|
|
|
|
Use: "lsjson remote:path",
|
|
|
|
Short: `List directories and objects in the path in JSON format.`,
|
|
|
|
Long: `List directories and objects in the path in JSON format.
|
|
|
|
|
|
|
|
The output is an array of Items, where each Item looks like this
|
|
|
|
|
|
|
|
{
|
|
|
|
"Hashes" : {
|
|
|
|
"SHA-1" : "f572d396fae9206628714fb2ce00f72e94f2258f",
|
|
|
|
"MD5" : "b1946ac92492d2347c6235b4d2611184",
|
|
|
|
"DropboxHash" : "ecb65bb98f9d905b70458986c39fcbad7715e5f2fcc3b1f07767d7c83e2438cc"
|
|
|
|
},
|
2018-05-13 08:19:06 +00:00
|
|
|
"ID": "y2djkhiujf83u33",
|
2017-06-12 17:40:20 +00:00
|
|
|
"IsDir" : false,
|
2018-05-13 09:37:46 +00:00
|
|
|
"MimeType" : "application/octet-stream",
|
2017-06-12 17:40:20 +00:00
|
|
|
"ModTime" : "2017-05-31T16:15:57.034468261+01:00",
|
|
|
|
"Name" : "file.txt",
|
2018-03-09 08:44:02 +00:00
|
|
|
"Encrypted" : "v0qpsdq8anpci8n929v3uu9338",
|
2017-06-12 17:40:20 +00:00
|
|
|
"Path" : "full/path/goes/here/file.txt",
|
|
|
|
"Size" : 6
|
|
|
|
}
|
|
|
|
|
2018-03-09 08:44:02 +00:00
|
|
|
If --hash is not specified the Hashes property won't be emitted.
|
2017-06-12 17:40:20 +00:00
|
|
|
|
|
|
|
If --no-modtime is specified then ModTime will be blank.
|
|
|
|
|
2018-03-09 08:44:02 +00:00
|
|
|
If --encrypted is not specified the Encrypted won't be emitted.
|
|
|
|
|
2018-01-31 12:34:23 +00:00
|
|
|
The Path field will only show folders below the remote path being listed.
|
|
|
|
If "remote:path" contains the file "subfolder/file.txt", the Path for "file.txt"
|
|
|
|
will be "subfolder/file.txt", not "remote:path/subfolder/file.txt".
|
|
|
|
When used without --recursive the Path will always be the same as Name.
|
|
|
|
|
2017-06-12 17:40:20 +00:00
|
|
|
The time is in RFC3339 format with nanosecond precision.
|
|
|
|
|
|
|
|
The whole output can be processed as a JSON blob, or alternatively it
|
|
|
|
can be processed line by line as each item is written one to a line.
|
2018-01-06 17:00:20 +00:00
|
|
|
` + lshelp.Help,
|
2017-06-12 17:40:20 +00:00
|
|
|
Run: func(command *cobra.Command, args []string) {
|
|
|
|
cmd.CheckArgs(1, 1, command, args)
|
|
|
|
fsrc := cmd.NewFsSrc(args)
|
2018-03-09 08:44:02 +00:00
|
|
|
var cipher crypt.Cipher
|
|
|
|
if showEncrypted {
|
2018-05-14 17:06:57 +00:00
|
|
|
fsInfo, _, _, config, err := fs.ConfigFs(args[0])
|
2018-03-09 08:44:02 +00:00
|
|
|
if err != nil {
|
|
|
|
log.Fatalf(err.Error())
|
|
|
|
}
|
|
|
|
if fsInfo.Name != "crypt" {
|
|
|
|
log.Fatalf("The remote needs to be of type \"crypt\"")
|
|
|
|
}
|
2018-05-14 17:06:57 +00:00
|
|
|
cipher, err = crypt.NewCipher(config)
|
2018-03-09 08:44:02 +00:00
|
|
|
if err != nil {
|
|
|
|
log.Fatalf(err.Error())
|
|
|
|
}
|
|
|
|
}
|
2017-06-12 17:40:20 +00:00
|
|
|
cmd.Run(false, false, command, func() error {
|
|
|
|
fmt.Println("[")
|
|
|
|
first := true
|
2018-01-12 16:30:54 +00:00
|
|
|
err := walk.Walk(fsrc, "", false, operations.ConfigMaxDepth(recurse), func(dirPath string, entries fs.DirEntries, err error) error {
|
2017-06-12 17:40:20 +00:00
|
|
|
if err != nil {
|
2018-01-12 16:30:54 +00:00
|
|
|
fs.CountError(err)
|
2017-06-12 17:40:20 +00:00
|
|
|
fs.Errorf(dirPath, "error listing: %v", err)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
for _, entry := range entries {
|
|
|
|
item := lsJSON{
|
2018-05-13 09:37:46 +00:00
|
|
|
Path: entry.Remote(),
|
|
|
|
Name: path.Base(entry.Remote()),
|
|
|
|
Size: entry.Size(),
|
|
|
|
MimeType: fs.MimeTypeDirEntry(entry),
|
2017-06-12 17:40:20 +00:00
|
|
|
}
|
|
|
|
if !noModTime {
|
|
|
|
item.ModTime = Timestamp(entry.ModTime())
|
|
|
|
}
|
2018-03-09 08:44:02 +00:00
|
|
|
if cipher != nil {
|
|
|
|
switch entry.(type) {
|
|
|
|
case fs.Directory:
|
|
|
|
item.Encrypted = cipher.EncryptDirName(path.Base(entry.Remote()))
|
|
|
|
case fs.Object:
|
|
|
|
item.Encrypted = cipher.EncryptFileName(path.Base(entry.Remote()))
|
|
|
|
default:
|
|
|
|
fs.Errorf(nil, "Unknown type %T in listing", entry)
|
|
|
|
}
|
|
|
|
}
|
2018-05-13 08:19:06 +00:00
|
|
|
if do, ok := entry.(fs.IDer); ok {
|
|
|
|
item.ID = do.ID()
|
|
|
|
}
|
2017-06-12 17:40:20 +00:00
|
|
|
switch x := entry.(type) {
|
2017-06-30 12:37:29 +00:00
|
|
|
case fs.Directory:
|
2017-06-12 17:40:20 +00:00
|
|
|
item.IsDir = true
|
|
|
|
case fs.Object:
|
|
|
|
item.IsDir = false
|
|
|
|
if showHash {
|
|
|
|
item.Hashes = make(map[string]string)
|
|
|
|
for _, hashType := range x.Fs().Hashes().Array() {
|
|
|
|
hash, err := x.Hash(hashType)
|
|
|
|
if err != nil {
|
|
|
|
fs.Errorf(x, "Failed to read hash: %v", err)
|
|
|
|
} else if hash != "" {
|
|
|
|
item.Hashes[hashType.String()] = hash
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
fs.Errorf(nil, "Unknown type %T in listing", entry)
|
|
|
|
}
|
|
|
|
out, err := json.Marshal(item)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "failed to marshal list object")
|
|
|
|
}
|
|
|
|
if first {
|
|
|
|
first = false
|
|
|
|
} else {
|
|
|
|
fmt.Print(",\n")
|
|
|
|
}
|
|
|
|
_, err = os.Stdout.Write(out)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "failed to write to output")
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "error listing JSON")
|
|
|
|
}
|
|
|
|
if !first {
|
|
|
|
fmt.Println()
|
|
|
|
}
|
|
|
|
fmt.Println("]")
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
}
|