func download(c cli.Command) {
var (
arglen = len(c.Args())
objectName string
path = c.Flag("path").String()
)
switch arglen {
case 1:
objectName = c.Arg(0).String()
case 2:
objectName = c.Arg(1).String()
container = c.Arg(0).String()
}
if blank(container) || blank(objectName) {
log.Fatal(errorNotEnough)
}
if blank(path) {
path = objectName
}
reader, err := api.Container(container).Object(objectName).GetReader()
if err != nil {
log.Fatal(err)
}
defer reader.Close()
fmt.Printf("downloading %s->%s from %s\n", objectName, path, container)
f, err := os.Create(path)
if err != nil {
log.Fatal(err)
}
n, err := io.Copy(f, reader)
if err != nil {
log.Fatal(err)
}
fmt.Printf("downloaded %s, %d bytes\n", objectName, n)
}
func list(c cli.Command) {
var (
arglen = len(c.Args())
table = tablewriter.NewWriter(os.Stdout)
)
if arglen == 0 && (blank(container) || c.Flag("type").String() == "storage") {
containers, err := api.ContainersInfo()
if err != nil {
log.Fatal(err)
}
table.SetHeader([]string{"Name", "Objects", "Type"})
for _, cont := range containers {
v := []string{cont.Name, fmt.Sprint(cont.ObjectCount), cont.Type}
table.Append(v)
}
table.Render()
return
}
if arglen == 1 {
container = c.Arg(0).String()
}
if blank(container) {
log.Fatal(errorNotEnough)
}
objects, err := api.Container(container).ObjectsInfo()
if err != nil {
log.Fatal(err)
}
table.SetHeader([]string{"Name", "Size", "Downloaded"})
for _, object := range objects {
v := []string{object.Name, fmt.Sprint(object.Size), fmt.Sprint(object.Downloaded)}
table.Append(v)
}
table.Render()
}
func cmRoll(c cli.Command) {
role := c.Flag("role").String()
if len(role) == 0 && c.Flag("force").Get() != true {
log.Fatalln("Must specify -f option to run with no `role` filter specified")
} else {
cmRunRoll(role, "")
}
}
// info prints information about storage
func info(c cli.Command) {
var (
containerName = container
objectName string
data interface{}
err error
arglen = len(c.Args())
command = c.Flag("type").String()
)
defer func() {
if err != nil {
log.Fatal(err)
}
if blank(containerName) || command == "storage" {
data = api.Info()
} else {
containerApi := api.Container(containerName)
if blank(objectName) {
data, err = containerApi.Info()
} else {
data, err = containerApi.Object(objectName).Info()
}
}
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", data)
}()
if arglen > 0 {
if command == "container" {
containerName = c.Arg(0).String()
return
}
command = "object"
if !blank(containerName) && arglen == 1 {
objectName = c.Arg(0).String()
return
}
if arglen == 2 {
containerName = c.Arg(0).String()
objectName = c.Arg(1).String()
return
}
}
if command == "container" && !blank(containerName) {
return
}
if command == "storage" {
return
}
err = errorNotEnough
}
func remove(c cli.Command) {
var (
arglen = len(c.Args())
object string
err error
message string
objects []storage.ObjectAPI
)
if arglen == 2 {
container = c.Arg(0).String()
object = c.Arg(1).String()
}
if arglen == 1 {
if c.Flag("type").String() == "container" {
container = c.Arg(0).String()
} else {
object = c.Arg(0).String()
}
}
if blank(container) {
log.Fatal(errorNotEnough)
}
if blank(object) {
containerApi := api.Container(container)
err = containerApi.Remove()
// forced removal of container
if err == storage.ErrorConianerNotEmpty && c.Flag("force").Get().(bool) {
fmt.Println("removing all objects of", container)
objects, err = containerApi.Objects()
if err != nil {
log.Fatal(err)
}
for _, object := range objects {
err = object.Remove()
// skipping NotFound errors as non-critical
if err != nil && err != storage.ErrorObjectNotFound {
log.Fatal(err)
}
}
err = containerApi.Remove()
}
message = fmt.Sprintf("container %s removed", container)
} else {
err = api.Container(container).Object(object).Remove()
message = fmt.Sprintf("object %s removed in container %s", object, container)
}
if err != nil {
log.Fatal(err)
}
fmt.Println(message)
}
func nodeList(c cli.Command) {
client, _ := api.NewClient(api.DefaultConfig())
catalog := client.Catalog()
nodes, _, err := catalog.Service("cascade", c.Flag("role").String(), nil)
if err != nil {
log.Fatalln("Err: ", err)
}
for _, node := range nodes {
fmt.Println(node.Node, node.Address+":")
for _, role := range node.ServiceTags {
fmt.Println(" -", role)
}
}
}
func serviceFind(c cli.Command) {
client, _ := api.NewClient(api.DefaultConfig())
catalog := client.Catalog()
if len(c.Args().GetAll()) == 0 {
log.Fatalln("err: missing <servicename> argument")
}
nodes, _, err := catalog.Service(c.Arg(0).String(), c.Flag("type").String(), nil)
if err != nil {
log.Fatalln("err: ", err)
}
fmt.Println(c.Arg(0).String() + ":")
for _, node := range nodes {
fmt.Println(" - host:", node.Node)
fmt.Println(" address:", node.Address)
fmt.Println(" port:", node.ServicePort)
fmt.Println(" tags:", strings.Join(node.ServiceTags, ", "))
}
}
func styleByFlags(str string, c cli.Command) string {
if c.Flag("loudly").Get() == true {
str = louden(str)
}
if c.Flag("color").String() != "" {
str = colorize(str, c.Flag("color").String())
}
return str
}
func cmRoll(c cli.Command) {
cmRunRoll(c.Flag("role").String(), "")
}
func readFlag(c cli.Command, name, env string) string {
if len(os.Getenv(env)) > 0 {
return os.Getenv(env)
}
return c.Flag(name).String()
}