362 lines
9.1 KiB
Go
362 lines
9.1 KiB
Go
// Copyright (C) 2014 Audrius Butkevičius
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/AudriusButkevicius/cli"
|
|
"github.com/syncthing/syncthing/lib/config"
|
|
"github.com/syncthing/syncthing/lib/fs"
|
|
)
|
|
|
|
func init() {
|
|
cliCommands = append(cliCommands, cli.Command{
|
|
Name: "folders",
|
|
HideHelp: true,
|
|
Usage: "Folder command group",
|
|
Subcommands: []cli.Command{
|
|
{
|
|
Name: "list",
|
|
Usage: "List available folders",
|
|
Requires: &cli.Requires{},
|
|
Action: foldersList,
|
|
},
|
|
{
|
|
Name: "add",
|
|
Usage: "Add a new folder",
|
|
Requires: &cli.Requires{"folder id", "directory"},
|
|
Action: foldersAdd,
|
|
},
|
|
{
|
|
Name: "remove",
|
|
Usage: "Remove an existing folder",
|
|
Requires: &cli.Requires{"folder id"},
|
|
Action: foldersRemove,
|
|
},
|
|
{
|
|
Name: "override",
|
|
Usage: "Override changes from other nodes for a master folder",
|
|
Requires: &cli.Requires{"folder id"},
|
|
Action: foldersOverride,
|
|
},
|
|
{
|
|
Name: "get",
|
|
Usage: "Get a property of a folder",
|
|
Requires: &cli.Requires{"folder id", "property"},
|
|
Action: foldersGet,
|
|
},
|
|
{
|
|
Name: "set",
|
|
Usage: "Set a property of a folder",
|
|
Requires: &cli.Requires{"folder id", "property", "value..."},
|
|
Action: foldersSet,
|
|
},
|
|
{
|
|
Name: "unset",
|
|
Usage: "Unset a property of a folder",
|
|
Requires: &cli.Requires{"folder id", "property"},
|
|
Action: foldersUnset,
|
|
},
|
|
{
|
|
Name: "devices",
|
|
Usage: "Folder devices command group",
|
|
HideHelp: true,
|
|
Subcommands: []cli.Command{
|
|
{
|
|
Name: "list",
|
|
Usage: "List of devices which the folder is shared with",
|
|
Requires: &cli.Requires{"folder id"},
|
|
Action: foldersDevicesList,
|
|
},
|
|
{
|
|
Name: "add",
|
|
Usage: "Share a folder with a device",
|
|
Requires: &cli.Requires{"folder id", "device id"},
|
|
Action: foldersDevicesAdd,
|
|
},
|
|
{
|
|
Name: "remove",
|
|
Usage: "Unshare a folder with a device",
|
|
Requires: &cli.Requires{"folder id", "device id"},
|
|
Action: foldersDevicesRemove,
|
|
},
|
|
{
|
|
Name: "clear",
|
|
Usage: "Unshare a folder with all devices",
|
|
Requires: &cli.Requires{"folder id"},
|
|
Action: foldersDevicesClear,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
}
|
|
|
|
func foldersList(c *cli.Context) {
|
|
cfg := getConfig(c)
|
|
first := true
|
|
writer := newTableWriter()
|
|
for _, folder := range cfg.Folders {
|
|
if !first {
|
|
fmt.Fprintln(writer)
|
|
}
|
|
fs := folder.Filesystem()
|
|
fmt.Fprintln(writer, "ID:\t", folder.ID, "\t")
|
|
fmt.Fprintln(writer, "Path:\t", fs.URI(), "\t(directory)")
|
|
fmt.Fprintln(writer, "Path type:\t", fs.Type(), "\t(directory-type)")
|
|
fmt.Fprintln(writer, "Folder type:\t", folder.Type, "\t(type)")
|
|
fmt.Fprintln(writer, "Ignore permissions:\t", folder.IgnorePerms, "\t(permissions)")
|
|
fmt.Fprintln(writer, "Rescan interval in seconds:\t", folder.RescanIntervalS, "\t(rescan)")
|
|
|
|
if folder.Versioning.Type != "" {
|
|
fmt.Fprintln(writer, "Versioning:\t", folder.Versioning.Type, "\t(versioning)")
|
|
for key, value := range folder.Versioning.Params {
|
|
fmt.Fprintf(writer, "Versioning %s:\t %s \t(versioning-%s)\n", key, value, key)
|
|
}
|
|
}
|
|
first = false
|
|
}
|
|
writer.Flush()
|
|
}
|
|
|
|
func foldersAdd(c *cli.Context) {
|
|
cfg := getConfig(c)
|
|
abs, err := filepath.Abs(c.Args()[1])
|
|
die(err)
|
|
folder := config.FolderConfiguration{
|
|
ID: c.Args()[0],
|
|
Path: filepath.Clean(abs),
|
|
FilesystemType: fs.FilesystemTypeBasic,
|
|
}
|
|
cfg.Folders = append(cfg.Folders, folder)
|
|
setConfig(c, cfg)
|
|
}
|
|
|
|
func foldersRemove(c *cli.Context) {
|
|
cfg := getConfig(c)
|
|
rid := c.Args()[0]
|
|
for i, folder := range cfg.Folders {
|
|
if folder.ID == rid {
|
|
last := len(cfg.Folders) - 1
|
|
cfg.Folders[i] = cfg.Folders[last]
|
|
cfg.Folders = cfg.Folders[:last]
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|
|
|
|
func foldersOverride(c *cli.Context) {
|
|
cfg := getConfig(c)
|
|
rid := c.Args()[0]
|
|
for _, folder := range cfg.Folders {
|
|
if folder.ID == rid && folder.Type == config.FolderTypeSendOnly {
|
|
response := httpPost(c, "db/override", "")
|
|
if response.StatusCode != 200 {
|
|
err := fmt.Sprint("Failed to override changes\nStatus code: ", response.StatusCode)
|
|
body := string(responseToBArray(response))
|
|
if body != "" {
|
|
err += "\nBody: " + body
|
|
}
|
|
die(err)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
die("Folder " + rid + " not found or folder not master")
|
|
}
|
|
|
|
func foldersGet(c *cli.Context) {
|
|
cfg := getConfig(c)
|
|
rid := c.Args()[0]
|
|
arg := strings.ToLower(c.Args()[1])
|
|
for _, folder := range cfg.Folders {
|
|
if folder.ID != rid {
|
|
continue
|
|
}
|
|
if strings.HasPrefix(arg, "versioning-") {
|
|
arg = arg[11:]
|
|
value, ok := folder.Versioning.Params[arg]
|
|
if ok {
|
|
fmt.Println(value)
|
|
return
|
|
}
|
|
die("Versioning property " + c.Args()[1][11:] + " not found")
|
|
}
|
|
switch arg {
|
|
case "directory":
|
|
fmt.Println(folder.Filesystem().URI())
|
|
case "directory-type":
|
|
fmt.Println(folder.Filesystem().Type())
|
|
case "type":
|
|
fmt.Println(folder.Type)
|
|
case "permissions":
|
|
fmt.Println(folder.IgnorePerms)
|
|
case "rescan":
|
|
fmt.Println(folder.RescanIntervalS)
|
|
case "versioning":
|
|
if folder.Versioning.Type != "" {
|
|
fmt.Println(folder.Versioning.Type)
|
|
}
|
|
default:
|
|
die("Invalid property: " + c.Args()[1] + "\nAvailable properties: directory, directory-type, type, permissions, versioning, versioning-<key>")
|
|
}
|
|
return
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|
|
|
|
func foldersSet(c *cli.Context) {
|
|
rid := c.Args()[0]
|
|
arg := strings.ToLower(c.Args()[1])
|
|
val := strings.Join(c.Args()[2:], " ")
|
|
cfg := getConfig(c)
|
|
for i, folder := range cfg.Folders {
|
|
if folder.ID != rid {
|
|
continue
|
|
}
|
|
if strings.HasPrefix(arg, "versioning-") {
|
|
cfg.Folders[i].Versioning.Params[arg[11:]] = val
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
switch arg {
|
|
case "directory":
|
|
cfg.Folders[i].Path = val
|
|
case "directory-type":
|
|
var fsType fs.FilesystemType
|
|
fsType.UnmarshalText([]byte(val))
|
|
cfg.Folders[i].FilesystemType = fsType
|
|
case "type":
|
|
var t config.FolderType
|
|
if err := t.UnmarshalText([]byte(val)); err != nil {
|
|
die("Invalid folder type: " + err.Error())
|
|
}
|
|
cfg.Folders[i].Type = t
|
|
case "permissions":
|
|
cfg.Folders[i].IgnorePerms = parseBool(val)
|
|
case "rescan":
|
|
cfg.Folders[i].RescanIntervalS = parseInt(val)
|
|
case "versioning":
|
|
cfg.Folders[i].Versioning.Type = val
|
|
default:
|
|
die("Invalid property: " + c.Args()[1] + "\nAvailable properties: directory, master, permissions, versioning, versioning-<key>")
|
|
}
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|
|
|
|
func foldersUnset(c *cli.Context) {
|
|
rid := c.Args()[0]
|
|
arg := strings.ToLower(c.Args()[1])
|
|
cfg := getConfig(c)
|
|
for i, folder := range cfg.Folders {
|
|
if folder.ID != rid {
|
|
continue
|
|
}
|
|
if strings.HasPrefix(arg, "versioning-") {
|
|
arg = arg[11:]
|
|
if _, ok := folder.Versioning.Params[arg]; ok {
|
|
delete(cfg.Folders[i].Versioning.Params, arg)
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
die("Versioning property " + c.Args()[1][11:] + " not found")
|
|
}
|
|
switch arg {
|
|
case "versioning":
|
|
cfg.Folders[i].Versioning.Type = ""
|
|
cfg.Folders[i].Versioning.Params = make(map[string]string)
|
|
default:
|
|
die("Invalid property: " + c.Args()[1] + "\nAvailable properties: versioning, versioning-<key>")
|
|
}
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|
|
|
|
func foldersDevicesList(c *cli.Context) {
|
|
rid := c.Args()[0]
|
|
cfg := getConfig(c)
|
|
for _, folder := range cfg.Folders {
|
|
if folder.ID != rid {
|
|
continue
|
|
}
|
|
for _, device := range folder.Devices {
|
|
fmt.Println(device.DeviceID)
|
|
}
|
|
return
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|
|
|
|
func foldersDevicesAdd(c *cli.Context) {
|
|
rid := c.Args()[0]
|
|
nid := parseDeviceID(c.Args()[1])
|
|
cfg := getConfig(c)
|
|
for i, folder := range cfg.Folders {
|
|
if folder.ID != rid {
|
|
continue
|
|
}
|
|
for _, device := range folder.Devices {
|
|
if device.DeviceID == nid {
|
|
die("Device " + c.Args()[1] + " is already part of this folder")
|
|
}
|
|
}
|
|
for _, device := range cfg.Devices {
|
|
if device.DeviceID == nid {
|
|
cfg.Folders[i].Devices = append(folder.Devices, config.FolderDeviceConfiguration{
|
|
DeviceID: device.DeviceID,
|
|
})
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
}
|
|
die("Device " + c.Args()[1] + " not found in device list")
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|
|
|
|
func foldersDevicesRemove(c *cli.Context) {
|
|
rid := c.Args()[0]
|
|
nid := parseDeviceID(c.Args()[1])
|
|
cfg := getConfig(c)
|
|
for ri, folder := range cfg.Folders {
|
|
if folder.ID != rid {
|
|
continue
|
|
}
|
|
for ni, device := range folder.Devices {
|
|
if device.DeviceID == nid {
|
|
last := len(folder.Devices) - 1
|
|
cfg.Folders[ri].Devices[ni] = folder.Devices[last]
|
|
cfg.Folders[ri].Devices = cfg.Folders[ri].Devices[:last]
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
}
|
|
die("Device " + c.Args()[1] + " not found")
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|
|
|
|
func foldersDevicesClear(c *cli.Context) {
|
|
rid := c.Args()[0]
|
|
cfg := getConfig(c)
|
|
for i, folder := range cfg.Folders {
|
|
if folder.ID != rid {
|
|
continue
|
|
}
|
|
cfg.Folders[i].Devices = []config.FolderDeviceConfiguration{}
|
|
setConfig(c, cfg)
|
|
return
|
|
}
|
|
die("Folder " + rid + " not found")
|
|
}
|