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)
}
}
}
}
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,
})
}
}
// 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,
})
}
}
// 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,
})
}
}
// doSyncSession - Sync an object to multiple destination
func doSyncSession(sURLs syncURLs, bar *barSend, syncQueue chan bool, ssCh chan syncSession, wg *sync.WaitGroup, s *sessionV1) {
// waitgroup reply deferred until this function returns
defer wg.Done()
// hold lock for map updates inside session
s.Lock.Lock()
defer s.Lock.Unlock()
if !globalQuietFlag {
bar.SetCaption(sURLs.SourceContent.Name + ": ")
}
_, ok := s.Files[sURLs.SourceContent.Name]
if ok {
if !globalQuietFlag {
putFakeTarget(bar.NewProxyReader(&fakeReader{size: sURLs.SourceContent.Size}))
}
<-syncQueue // Signal that this copy routine is done.
return
}
reader, length, err := getSource(sURLs.SourceContent.Name)
if err != nil {
if !globalQuietFlag {
bar.ErrorGet(int64(length))
}
ssCh <- syncSession{
Error: iodine.New(err, map[string]string{"URL": sURLs.SourceContent.Name}),
Done: false,
}
}
defer reader.Close()
var targetURLs []string
for _, targetContent := range sURLs.TargetContents {
targetURLs = append(targetURLs, targetContent.Name)
}
var newReader io.Reader
switch globalQuietFlag || globalJSONFlag {
case true:
console.Infos(SyncMessage{
Source: sURLs.SourceContent.Name,
Targets: targetURLs,
})
newReader = yielder.NewReader(reader)
default:
// set up progress
newReader = bar.NewProxyReader(yielder.NewReader(reader))
}
for err := range putTargets(targetURLs, length, newReader) {
if err != nil {
if !globalQuietFlag {
bar.ErrorPut(int64(length))
}
ssCh <- syncSession{
Error: iodine.New(err, nil),
Done: false,
}
}
}
<-syncQueue // Signal that this copy routine is done.
// store files which have finished copying
s.Files[sURLs.SourceContent.Name] = struct{}{}
}
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)
}
}