func zkResolveWildcards(wr *wrangler.Wrangler, args []string) ([]string, error) {
zkts, ok := wr.TopoServer().(*zktopo.Server)
if !ok {
return args, nil
}
return zk.ResolveWildcards(zkts.GetZConn(), args)
}
func cmdChmod(subFlags *flag.FlagSet, args []string) {
subFlags.Parse(args)
if subFlags.NArg() < 2 {
log.Fatal("chmod: no permission specified")
}
mode := subFlags.Arg(0)
if mode[0] != 'n' {
log.Fatal("chmod: invalid mode")
}
addPerms := false
if mode[1] == '+' {
addPerms = true
} else if mode[1] != '-' {
log.Fatal("chmod: invalid mode")
}
var permMask uint32
for _, c := range mode[2:] {
permMask |= charPermMap[string(c)]
}
resolved, err := zk.ResolveWildcards(zconn, subFlags.Args()[1:])
if err != nil {
log.Fatalf("chmod: invalid wildcards: %v", err)
}
if len(resolved) == 0 {
// the wildcards didn't result in anything, we're done
return
}
hasError := false
for _, arg := range resolved {
zkPath := fixZkPath(arg)
aclv, _, err := zconn.ACL(zkPath)
if err != nil {
hasError = true
log.Warningf("chmod: cannot set access %v: %v", zkPath, err)
continue
}
if addPerms {
aclv[0].Perms |= permMask
} else {
aclv[0].Perms &= ^permMask
}
err = zconn.SetACL(zkPath, aclv, -1)
if err != nil {
hasError = true
log.Warningf("chmod: cannot set access %v: %v", zkPath, err)
continue
}
}
if hasError {
os.Exit(1)
}
}
func cmdRm(subFlags *flag.FlagSet, args []string) {
var (
force = subFlags.Bool("f", false, "no warning on nonexistent node")
recursiveDelete = subFlags.Bool("r", false, "recursive delete")
forceAndRecursive = subFlags.Bool("rf", false, "shorthand for -r -f")
)
subFlags.Parse(args)
*force = *force || *forceAndRecursive
*recursiveDelete = *recursiveDelete || *forceAndRecursive
if subFlags.NArg() == 0 {
log.Fatal("rm: no path specified")
}
if *recursiveDelete {
for _, arg := range subFlags.Args() {
zkPath := fixZkPath(arg)
if strings.Count(zkPath, "/") < 4 {
log.Fatalf("rm: overly general path: %v", zkPath)
}
}
}
resolved, err := zk.ResolveWildcards(zconn, subFlags.Args())
if err != nil {
log.Fatalf("rm: invalid wildcards: %v", err)
}
if len(resolved) == 0 {
// the wildcards didn't result in anything, we're done
return
}
hasError := false
for _, arg := range resolved {
zkPath := fixZkPath(arg)
var err error
if *recursiveDelete {
err = zk.DeleteRecursive(zconn, zkPath, -1)
} else {
err = zconn.Delete(zkPath, -1)
}
if err != nil && (!*force || !zookeeper.IsError(err, zookeeper.ZNONODE)) {
hasError = true
log.Warningf("rm: cannot delete %v: %v", zkPath, err)
}
}
if hasError {
// to be consistent with the command line 'rm -f', return
// 0 if using 'zk rm -f' and the file doesn't exist.
os.Exit(1)
}
}
func cmdStat(subFlags *flag.FlagSet, args []string) {
var (
force = subFlags.Bool("f", false, "no warning on nonexistent node")
)
subFlags.Parse(args)
if subFlags.NArg() == 0 {
log.Fatal("stat: no path specified")
}
resolved, err := zk.ResolveWildcards(zconn, subFlags.Args())
if err != nil {
log.Fatalf("stat: invalid wildcards: %v", err)
}
if len(resolved) == 0 {
// the wildcards didn't result in anything, we're done
return
}
hasError := false
for _, arg := range resolved {
zkPath := fixZkPath(arg)
acls, stat, err := zconn.ACL(zkPath)
if stat == nil {
err = fmt.Errorf("no such node")
}
if err != nil {
hasError = true
if !*force || !zookeeper.IsError(err, zookeeper.ZNONODE) {
log.Warningf("stat: cannot access %v: %v", zkPath, err)
}
continue
}
fmt.Printf("Path: %s\n", zkPath)
fmt.Printf("Created: %s\n", stat.CTime().Format(timeFmtMicro))
fmt.Printf("Modified: %s\n", stat.MTime().Format(timeFmtMicro))
fmt.Printf("Size: %v\n", stat.DataLength())
fmt.Printf("Children: %v\n", stat.NumChildren())
fmt.Printf("Version: %v\n", stat.Version())
fmt.Printf("Ephemeral: %v\n", stat.EphemeralOwner())
fmt.Printf("ACL:\n")
for _, acl := range acls {
fmt.Printf(" %v:%v %v\n", acl.Scheme, acl.Id, fmtAcl(acl))
}
}
if hasError {
os.Exit(1)
}
}
func (ex ZkExplorer) HandlePath(actionRepo *ActionRepository, zkPath string, r *http.Request) interface{} {
result := NewZkResult(zkPath)
if zkPath == "/zk" {
cells, err := zk.ResolveWildcards(ex.zconn, []string{"/zk/*"})
if err != nil {
result.Error = err.Error()
return result
}
for i, cell := range cells {
cells[i] = cell[4:] // cut off "/zk/"
}
result.Children = cells
sort.Strings(result.Children)
return result
}
data, _, err := ex.zconn.Get(zkPath)
if err != nil {
result.Error = err.Error()
return result
}
if m, _ := path.Match("/zk/global/vt/keyspaces/*", zkPath); m {
keyspace := path.Base(zkPath)
actionRepo.PopulateKeyspaceActions(result.Actions, keyspace)
} else if m, _ := path.Match("/zk/global/vt/keyspaces/*/shards/*", zkPath); m {
zkPathParts := strings.Split(zkPath, "/")
keyspace := zkPathParts[5]
shard := zkPathParts[7]
actionRepo.PopulateShardActions(result.Actions, keyspace, shard)
} else if m, _ := path.Match("/zk/*/vt/tablets/*", result.Path); m {
zkPathParts := strings.Split(result.Path, "/")
alias := zkPathParts[2] + "-" + zkPathParts[5]
actionRepo.PopulateTabletActions(result.Actions, alias, r)
ex.addTabletLinks(data, result)
}
result.Data = data
children, _, err := ex.zconn.Children(zkPath)
if err != nil {
result.Error = err.Error()
return result
}
result.Children = children
sort.Strings(result.Children)
return result
}
func cmdCat(subFlags *flag.FlagSet, args []string) {
var (
longListing = subFlags.Bool("l", false, "long listing")
force = subFlags.Bool("f", false, "no warning on nonexistent node")
)
subFlags.Parse(args)
if subFlags.NArg() == 0 {
log.Fatal("cat: no path specified")
}
resolved, err := zk.ResolveWildcards(zconn, subFlags.Args())
if err != nil {
log.Fatalf("cat: invalid wildcards: %v", err)
}
if len(resolved) == 0 {
// the wildcards didn't result in anything, we're done
return
}
hasError := false
for _, arg := range resolved {
zkPath := fixZkPath(arg)
data, _, err := zconn.Get(zkPath)
if err != nil {
hasError = true
if !*force || !zookeeper.IsError(err, zookeeper.ZNONODE) {
log.Warningf("cat: cannot access %v: %v", zkPath, err)
}
} else {
if *longListing {
fmt.Printf("%v:\n", zkPath)
}
fmt.Print(data)
if len(data) > 0 && data[len(data)-1] != '\n' && (terminal.IsTerminal(os.Stdout.Fd()) || *longListing) {
fmt.Print("\n")
}
}
}
if hasError {
os.Exit(1)
}
}
func cmdLs(subFlags *flag.FlagSet, args []string) {
var (
longListing = subFlags.Bool("l", false, "long listing")
directoryListing = subFlags.Bool("d", false, "list directory instead of contents")
force = subFlags.Bool("f", false, "no warning on nonexistent node")
recursiveListing = subFlags.Bool("R", false, "recursive listing")
)
subFlags.Parse(args)
if subFlags.NArg() == 0 {
log.Fatal("ls: no path specified")
}
// FIXME(szopa): shadowing?
resolved, err := zk.ResolveWildcards(zconn, subFlags.Args())
if err != nil {
log.Fatalf("ls: invalid wildcards: %v", err)
}
if len(resolved) == 0 {
// the wildcards didn't result in anything, we're
// done.
return
}
hasError := false
needsHeader := len(resolved) > 1 && !*directoryListing
for _, arg := range resolved {
zkPath := fixZkPath(arg)
var children []string
var err error
isDir := true
if *directoryListing {
children = []string{""}
isDir = false
} else if *recursiveListing {
children, err = zk.ChildrenRecursive(zconn, zkPath)
} else {
children, _, err = zconn.Children(zkPath)
// Assume this is a file node if it has no children.
if len(children) == 0 {
children = []string{""}
isDir = false
}
}
if err != nil {
hasError = true
if !*force || !zookeeper.IsError(err, zookeeper.ZNONODE) {
log.Warningf("ls: cannot access %v: %v", zkPath, err)
}
}
// Show the full path when it helps.
showFullPath := false
if *recursiveListing {
showFullPath = true
} else if *longListing && (*directoryListing || !isDir) {
showFullPath = true
}
if needsHeader {
fmt.Printf("%v:\n", zkPath)
}
if len(children) > 0 {
if *longListing && isDir {
fmt.Printf("total: %v\n", len(children))
}
sort.Strings(children)
stats := make([]zk.Stat, len(children))
wg := sync.WaitGroup{}
f := func(i int) {
localPath := path.Join(zkPath, children[i])
stat, err := zconn.Exists(localPath)
if err != nil {
if !*force || !zookeeper.IsError(err, zookeeper.ZNONODE) {
log.Warningf("ls: cannot access: %v: %v", localPath, err)
}
} else {
stats[i] = stat
}
wg.Done()
}
for i := range children {
wg.Add(1)
go f(i)
}
wg.Wait()
for i, child := range children {
localPath := path.Join(zkPath, child)
if stat := stats[i]; stat != nil {
fmtPath(stat, localPath, showFullPath, *longListing)
}
}
}
if needsHeader {
fmt.Println()
}
}
if hasError {
os.Exit(1)
}
}
