func runAccessCmd(ctx *cli.Context) {
if !ctx.Args().Present() || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "access", 1) // last argument is exit code
}
if !isMcConfigExists() {
console.Fatals(ErrorMessage{
Message: "Please run \"mc config generate\"",
Error: iodine.New(errNotConfigured{}, nil),
})
}
config, err := getMcConfig()
if err != nil {
console.Fatals(ErrorMessage{
Message: "loading config file failed",
Error: iodine.New(err, nil),
})
}
acl := bucketACL(ctx.Args().First())
if !acl.isValidBucketACL() {
console.Fatals(ErrorMessage{
Message: "Valid types are [private, public, readonly].",
Error: iodine.New(errInvalidACL{acl: acl.String()}, nil),
})
}
for _, arg := range ctx.Args().Tail() {
targetURL, err := getExpandedURL(arg, config.Aliases)
if err != nil {
switch e := iodine.ToError(err).(type) {
case errUnsupportedScheme:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unknown type of URL ‘%s’", e.url),
Error: iodine.New(e, nil),
})
default:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to parse argument ‘%s’", arg),
Error: iodine.New(err, nil),
})
}
}
msg, err := doUpdateAccessCmd(targetURL, acl)
if err != nil {
console.Errors(ErrorMessage{
Message: msg,
Error: iodine.New(err, nil),
})
}
console.Infos(InfoMessage{
Message: msg,
})
}
}
// runListCmd - is a handler for mc ls command
func runListCmd(ctx *cli.Context) {
args := ctx.Args()
if globalAliasFlag {
if !ctx.Args().Present() {
args = []string{"."}
}
} else if !ctx.Args().Present() || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "ls", 1) // last argument is exit code
}
if !isMcConfigExists() {
console.Fatals(ErrorMessage{
Message: "Please run \"mc config generate\"",
Error: iodine.New(errNotConfigured{}, nil),
})
}
config, err := getMcConfig()
if err != nil {
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to read config file ‘%s’", mustGetMcConfigPath()),
Error: iodine.New(err, nil),
})
}
for _, arg := range args {
targetURL, err := getExpandedURL(arg, config.Aliases)
if err != nil {
switch e := iodine.ToError(err).(type) {
case errUnsupportedScheme:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unknown type of URL ‘%s’", e.url),
Error: iodine.New(e, nil),
})
default:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to parse argument ‘%s’", arg),
Error: iodine.New(err, nil),
})
}
}
// if recursive strip off the "..."
newTargetURL := stripRecursiveURL(targetURL)
err = doListCmd(newTargetURL, isURLRecursive(targetURL))
if err != nil {
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Failed to list ‘%s’", targetURL),
Error: iodine.New(err, map[string]string{"Target": targetURL}),
})
}
}
}
func sessionExecute(bar barSend, s *sessionV1) {
switch s.CommandType {
case "cp":
for cps := range doCopyCmdSession(bar, s) {
if cps.Error != nil {
console.Errors(ErrorMessage{
Message: "Failed with",
Error: iodine.New(cps.Error, nil),
})
}
if cps.Done {
if err := saveSession(s); err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
console.Println()
console.Infos(InfoMessage{
Message: "Session terminated. To resume session type ‘mc session resume " + s.SessionID + "’",
})
// this os.Exit is needed really to exit in-case of "os.Interrupt"
os.Exit(0)
}
}
case "sync":
for ss := range doSyncCmdSession(bar, s) {
if ss.Error != nil {
console.Errors(ErrorMessage{
Message: "Failed with",
Error: iodine.New(ss.Error, nil),
})
}
if ss.Done {
if err := saveSession(s); err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
console.Println()
console.Infos(InfoMessage{
Message: "Session terminated. To resume session type ‘mc session resume " + s.SessionID + "’",
})
// this os.Exit is needed really to exit in-case of "os.Interrupt"
os.Exit(0)
}
}
}
}
// runMakeBucketCmd is the handler for mc mb command
func runMakeBucketCmd(ctx *cli.Context) {
if !ctx.Args().Present() || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "mb", 1) // last argument is exit code
}
if !isMcConfigExists() {
console.Fatals(ErrorMessage{
Message: "Please run \"mc config generate\"",
Error: iodine.New(errNotConfigured{}, nil),
})
}
config, err := getMcConfig()
if err != nil {
console.Fatals(ErrorMessage{
Message: "Unable to read config file ‘" + mustGetMcConfigPath() + "’",
Error: iodine.New(err, nil),
})
}
for _, arg := range ctx.Args() {
targetURL, err := getExpandedURL(arg, config.Aliases)
if err != nil {
switch e := iodine.ToError(err).(type) {
case errUnsupportedScheme:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unknown type of URL ‘%s’", e.url),
Error: iodine.New(e, nil),
})
default:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to parse argument ‘%s’", arg),
Error: iodine.New(err, nil),
})
}
}
msg, err := doMakeBucketCmd(targetURL)
if err != nil {
console.Errors(ErrorMessage{
Message: msg,
Error: iodine.New(err, nil),
})
}
console.Infos(InfoMessage{
Message: msg,
})
}
}
func runCatCmd(ctx *cli.Context) {
if !ctx.Args().Present() || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "cat", 1) // last argument is exit code
}
if !isMcConfigExists() {
console.Fatals(ErrorMessage{
Message: "Please run \"mc config generate\"",
Error: iodine.New(errNotConfigured{}, nil),
})
}
config, err := getMcConfig()
if err != nil {
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to read config file ‘%s’", mustGetMcConfigPath()),
Error: iodine.New(err, nil),
})
}
// Convert arguments to URLs: expand alias, fix format...
for _, arg := range ctx.Args() {
sourceURL, err := getExpandedURL(arg, config.Aliases)
if err != nil {
switch e := iodine.ToError(err).(type) {
case errUnsupportedScheme:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unknown type of URL ‘%s’", e.url),
Error: iodine.New(e, nil),
})
default:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to parse argument ‘%s’", arg),
Error: iodine.New(err, nil),
})
}
}
errorMsg, err := doCatCmd(sourceURL)
if err != nil {
console.Fatals(ErrorMessage{
Message: errorMsg,
Error: iodine.New(err, nil),
})
}
}
}
// runUpdateCmd -
func runUpdateCmd(ctx *cli.Context) {
if ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "update", 1) // last argument is exit code
}
if !isMcConfigExists() {
console.Fatals(ErrorMessage{
Message: "Please run \"mc config generate\"",
Error: iodine.New(errNotConfigured{}, nil),
})
}
msg, err := doUpdateCheck()
if err != nil {
console.Fatals(ErrorMessage{
Message: msg,
Error: iodine.New(err, nil),
})
}
// no msg do not print one
if msg != "" {
console.Infos(InfoMessage{Message: msg})
}
}
// runDiffCmd - is a handler for mc diff command
func runDiffCmd(ctx *cli.Context) {
if len(ctx.Args()) != 2 || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "diff", 1) // last argument is exit code
}
if !isMcConfigExists() {
console.Fatals(ErrorMessage{
Message: "Please run \"mc config generate\"",
Error: iodine.New(errNotConfigured{}, nil),
})
}
config, err := getMcConfig()
if err != nil {
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to read config file ‘%s’", mustGetMcConfigPath()),
Error: iodine.New(err, nil),
})
}
firstURL := ctx.Args().First()
secondURL := ctx.Args()[1]
firstURL, err = getExpandedURL(firstURL, config.Aliases)
if err != nil {
switch iodine.ToError(err).(type) {
case errUnsupportedScheme:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unknown type of URL ‘%s’", firstURL),
Error: iodine.New(err, nil),
})
default:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to parse argument ‘%s’", firstURL),
Error: iodine.New(err, nil),
})
}
}
secondURL, err = getExpandedURL(secondURL, config.Aliases)
if err != nil {
switch iodine.ToError(err).(type) {
case errUnsupportedScheme:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unknown type of URL ‘%s’", secondURL),
Error: iodine.New(err, nil),
})
default:
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unable to parse argument ‘%s’", secondURL),
Error: iodine.New(err, nil),
})
}
}
if isURLRecursive(secondURL) {
console.Fatals(ErrorMessage{
Message: "Second URL cannot be recursive, diff command is unidirectional",
Error: iodine.New(errInvalidArgument{}, nil),
})
}
newFirstURL := stripRecursiveURL(firstURL)
for diff := range doDiffCmd(newFirstURL, secondURL, isURLRecursive(firstURL)) {
if diff.err != nil {
console.Fatals(ErrorMessage{
Message: diff.message,
Error: iodine.New(diff.err, nil),
})
}
console.Infos(InfoMessage{
Message: diff.message,
})
}
}
func runSessionCmd(ctx *cli.Context) {
if len(ctx.Args()) < 1 || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "session", 1) // last argument is exit code
}
if strings.TrimSpace(ctx.Args().First()) == "" {
cli.ShowCommandHelpAndExit(ctx, "session", 1) // last argument is exit code
}
if !isSessionDirExists() {
if err := createSessionDir(); err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
}
switch strings.TrimSpace(ctx.Args().First()) {
// list resumable sessions
case "list":
err := listSessions(sessionDir)
if err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
case "resume":
if len(ctx.Args().Tail()) != 1 {
cli.ShowCommandHelpAndExit(ctx, "session", 1) // last argument is exit code
}
if strings.TrimSpace(ctx.Args().Tail().First()) == "" {
cli.ShowCommandHelpAndExit(ctx, "session", 1) // last argument is exit code
}
sid := strings.TrimSpace(ctx.Args().Tail().First())
s, err := resumeSession(sid)
if err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
savedCwd, err := os.Getwd()
if err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
if s.RootPath != "" {
// chdir to RootPath
os.Chdir(s.RootPath)
}
var bar barSend
// set up progress bar
if !globalQuietFlag {
bar = newCpBar()
}
sessionExecute(bar, s)
if !globalQuietFlag {
bar.Finish()
if err := clearSession(sid); err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
// change dir back
os.Chdir(savedCwd)
}
// purge a requested pending session, if "*" purge everything
case "clear":
if len(ctx.Args().Tail()) != 1 {
cli.ShowCommandHelpAndExit(ctx, "session", 1) // last argument is exit code
}
if strings.TrimSpace(ctx.Args().Tail().First()) == "" {
cli.ShowCommandHelpAndExit(ctx, "session", 1) // last argument is exit code
}
if err := clearSession(strings.TrimSpace(ctx.Args().Tail().First())); err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
default:
cli.ShowCommandHelpAndExit(ctx, "session", 1) // last argument is exit code
}
}
func runSyncCmd(ctx *cli.Context) {
if len(ctx.Args()) < 2 || ctx.Args().First() == "help" {
cli.ShowCommandHelpAndExit(ctx, "sync", 1) // last argument is exit code
}
if !isMcConfigExists() {
console.Fatals(ErrorMessage{
Message: "Please run \"mc config generate\"",
Error: iodine.New(errNotConfigured{}, nil),
})
}
if !isSessionDirExists() {
if err := createSessionDir(); err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
}
s, err := newSession()
if err != nil {
console.Fatals(ErrorMessage{
Message: "Failed with",
Error: iodine.New(err, nil),
})
}
s.CommandType = "sync"
s.RootPath, _ = os.Getwd()
// extract URLs.
s.URLs, err = args2URLs(ctx.Args())
if err != nil {
console.Fatals(ErrorMessage{
Message: fmt.Sprintf("Unknown URL types found: ‘%s’", ctx.Args()),
Error: iodine.New(err, nil),
})
}
var bar barSend
// set up progress bar
if !globalQuietFlag {
bar = newCpBar()
}
for ss := range doSyncCmdSession(bar, s) {
if ss.Error != nil {
console.Errors(ErrorMessage{
Message: "Failed with",
Error: iodine.New(ss.Error, nil),
})
}
if ss.Done {
if err := saveSession(s); err != nil {
console.Fatals(ErrorMessage{
Message: "Failed wtih",
Error: iodine.New(err, nil),
})
}
console.Println()
console.Infos(InfoMessage{
Message: "Session terminated. To resume session type ‘mc session resume " + s.SessionID + "’",
})
// this os.Exit is needed really to exit in-case of "os.Interrupt"
os.Exit(0)
}
}
if !globalQuietFlag {
bar.Finish()
// ignore any error returned here
clearSession(s.SessionID)
}
}
