Filter by parent role mapping

[janfabry]

Take this case:

class a(A):
    class Hosts:
        app = [host0, host1]
        lb = [host2, host3]

    @map_roles(host=('app', 'lb'))
    class git(Git):
         pass

Now I can do the following to git show the load balancers:

> a git :host2 show
> a git :host3 show

However, instead of doing this individually, I would like to use the already defined lb role mapping. Something like:

 > a %lb git show

So when resolving the hosts to pass to Git, we will filter out the hosts that are not part of the lb role of the parent service. The difference is that filtering by host isolation happens after you select the service, while filtering by host mapping happens before - I think that makes sense, as the mappings come from the parent service.

[jonathanslenders]

Probably, this will be turned in a DSL to apply filters to the isolations.
First step is to make this possible from code, second is to invent a nice syntax for the interactive shell.

We can already do in code:

a.git[host0].show()
a.git[host1].show()

What we want is:

parent_hosts = a.hosts.filter('lb') # Returns a HostsContainer
a.git[parent_hosts].show()

Not sure what the best syntax for the shell would be, maybe something like this:

a git ::parent.lb show

The question is: how many other possibilities do we have, and does this syntax give us enough freedom to express all possibilities in the future without inventing even more syntax?

Something to think about. It's certainly worth implementing, if not too complicated.

[jonathanslenders]

I'm still working on this. Last weekend I was thinking about a better shell interface. Instead of a tree of commands, we should define a real context free grammar, in order to have nice autocompletion and no ambiguity.

The hard part is that we end up with different kinds of grammar, we have:

1. Calling node actions (any of these, not sure what is the easiest.):

git.checkout('commit')
git checkout commit

  # with isolation:
git[www1-brussels].checkout('commit')
git :www1-brussels checkout commit

1. Built-ins

cd /

1. In the SCP shell, going to another directory:

cd ../..

1. Adding special filters like your %lb, could for instance be possible like this:

git.checkout[~lb].checkout(...)

(except that I have no clue yet on how to evaluate ~lb without any dirty hacks.)

The hardest part is that we need a much more complex grammar than we already have, to express al this. Parsing is doable, but we have to keep autocompletion everywhere and it shouldn't become any harder for end-users to enter commands.

Further I'd like to add placeholders as suggestions when completing, e.g. when somebody types git checkout, it will be displayed as it.checkout(<commit>), where <commit> is greyed. When he continues typing, that part should be filled in. It should make discoverability of commands much easier.