2012/02/28/#juju-dev.txt

=== andrewsmedina_ is now known as andrewsmedina
=== andrewsmedina_ is now known as andrewsmedina
[08:54] <TheMue> rog: morning
[08:54] <rog> TheMue: hiya
=== Leseb_ is now known as Leseb
[13:15] <niemeyer> Alow
[13:25] <TheMue> niemeyer: hiya
[13:25] <TheMue> niemeyer: my propose of the continued machines based on yesterdays charms (has been a branch of that) is in
[13:33] <niemeyer> TheMue: Thanks
[13:33] <niemeyer> TheMue: I may only get to it tomorrow
[13:33] <niemeyer> TheMue: I'll try to stick to store work today, since I've been clearly failing at it
[13:34] <TheMue> niemeyer: ok, no prob, better keep concentration
[13:34] <TheMue> niemeyer: would part of state should I take next?
[13:38] <rog> lunch
[13:39] <rog> (outside in the sun!)
[13:43] <niemeyer> TheMue: Not sure..
[13:43] <TheMue> rog: enjoy. sun? (envy) here it is grey and wet
[13:43] <niemeyer> TheMue: Actually, wasn't there something to be done as a left over from the current work?
[13:43] <niemeyer> I recall something like that, but can't remind of it now
[13:44] <niemeyer> TheMue: Ah, yes.. zk => st
[13:44] <TheMue> niemeyer: state into all entities, but that's only very small
[13:44] <niemeyer> TheMue: Yeah, but has to be done
[13:44] <TheMue> niemeyer: yep, exactly
[13:44] <niemeyer> TheMue: Besides that, just pick something that moves the state forward
[13:44] <TheMue> niemeyer: ok, will do so
[13:45] <niemeyer> TheMue: Preferably in areas that do not conflict with changes going on in Python (relations)
[13:45] <niemeyer> andrewsmedina: Any progress there?
[13:45] <andrewsmedina> niemeyer: yes
[13:45] <niemeyer> andrewsmedina: Nice
[13:45] <TheMue> niemeyer: yep, no relations
[13:46] <andrewsmedina> niemeyer: I'm finishing the tests for port charm metadata subordinate to Go
[13:55] <niemeyer> andrewsmedina: Very neat
[13:55] <niemeyer> andrewsmedina: Thanks for working on that
[13:58] <andrewsmedina> niemeyer: :D
[14:26] <rog> wondering if anyone is up for sanity-checking a possible approach to making my ec2test fake ec2 server simulate eventual consistency issues
[14:26] <rog> fwereade, jimbaker?
[14:27] <fwereade> rog, I'm trying to finish something off atm, I'll ping you when I'm free
[14:27] <rog> fwereade: thanks
=== Leseb_ is now known as Leseb
[15:50] <niemeyer> Lunch time here..
[15:53] <fwereade> rog, sorry that took so long; can I be of service?
[15:54] <rog> fwereade: yes, thanks. gimme 1 minute.
[15:56] <rog> fwereade: bakc
[15:56] <rog> ck
[15:56] <rog> fwereade: so...
[15:56] <rog> fwereade: the object is to simulate the "eventual consistency" semantics of the ec2 server.
[15:56] <rog> fwereade: to that end, the idea is that all operations operate on an out-of-date version of the server data.
[15:57] <rog> fwereade: when a client makes a call, if it's a read-only request, we return the results from the out-of-date version.
[15:57] <rog> fwereade: if it's a modification request, we allocate any unique ids (instance ids, group ids etc) from the current version. then we queue up the operation to be executed later.
[15:57] <rog> fwereade: after every call, we execute one operation from the queue.
[15:57] <rog> fwereade: does that sound reasonable to you?
[15:57] <fwereade> rog, yes, I think so
[15:58] <rog> fwereade: i can't help feeling that there might be a large bear lurking in the room somewhere
[15:59] <rog> guess i can only try and see
[15:59] <fwereade> rog, I'm wondering though whether it might be good to have some way of varying the behaviour -- sometimes immediate consistency, sometimes irritatingly delayed
[15:59] <rog> fwereade: the idea is to allow the length of the queue to be specified when the server starts
[15:59] <rog> fwereade: i don't think having random behaviour is going to be good for reproducing failed tests
[15:59] <fwereade> rog, the trouble is you don't *really* want to do that *randomly*, or you're on a miserable path to unreproducible test failures
[16:00] <fwereade> snap :p
[16:00] <rog> fwereade: so i think we'd try all tests with "totally consistent" and "very delayed" behaviour
[16:01] <rog> fwereade: one question i can't quite decide on is if there are significant tests that might fail with random consistency but neither of the above scenarios
[16:01] <fwereade> rog, that's what's bugging me
[16:01] <fwereade> rog, I can see a plausible route towards repeatable random tests
[16:02] <jimbaker> rog, this sounds like what we do in the testing in the python code. not uniformly mind you
[16:02] <jimbaker> in terms of delays
[16:02] <rog> fwereade: what about concurrency?
[16:02] <fwereade> rog, where we store the seed that generated the queue-frobbing and can attach that
[16:03] <rog> fwereade: that assumes we generate requests deterministically.
[16:03] <fwereade> rog, ok, close-enough-to-repeatable to probably be a bit easier to reproduce
[16:03] <rog> fwereade: hence my question "what about concurrency"?
[16:03] <fwereade> rog, quite so; it may very well be that the difference is slight
[16:03] <rog> fwereade: i dunno.
[16:03] <fwereade> rog, and doesn't justify the effort
[16:04] <rog> fwereade: the other thing is that the above approach doesn't work if you can jump backwards and forwards in time.
[16:04] <fwereade> rog, in what sense?
[16:04] <rog> fwereade: because you need to keep several versions of the server state
[16:04] <rog> fwereade: with this approach we just keep one version and apply deltas
[16:04] <fwereade> rog, ah got you
[16:05] <rog> fwereade: hmm
[16:05] <rog> fwereade: although
[16:06] <rog> fwereade: if delta application is deterministic
[16:06] <rog> fwereade: then we can keep several versions and apply deltas to each of them as appropriate
[16:07] <fwereade> rog, sorry, I think I'm lost...
[16:07] <rog> fwereade: we could have several versions of the state, each representing the state at some point within the queue of pending operations
[16:08] <rog> fwereade: as deltas move through the queue, they get applied to each state in turn. or maybe not in turn... to simulate the random ordering
[16:09] <rog> fwereade: assuming s1+delta1+delta2 == s1+delta2+delta1 it should be ok
[16:09] <fwereade> rog, yes, I understand that bit; ah, yes, ok, we can have a separate queue of operations for each... er, time-slice of the server
[16:09] <rog> fwereade: unfortunately that last isn't quite true, although it is for most things AFAICS
[16:10] <fwereade> rog, thinking more though; it might be good to propose it with just the discussed boundary-condition checks, which will be useful if not complete
[16:10] <rog> fwereade: for instance, if the user does AddSecurityGroupAuth followed by RevokeSecurityGroupAuth, what's the result if the ops get reordered?
[16:11] <fwereade> rog, finding some happy medium between randomness and repeatability can wait
[16:11] <fwereade> rog, I have no idea, and that worries me
[16:11] <rog> fwereade: yeah, i think so. and that probably makes it easier to do something more sophisticated later on if we deem it useful
[16:11] <rog> fwereade: i *wish* there was some documentation on what semantics you can expect from ec2
[16:12] <fwereade> rog, hopefully
[16:12] <rog> fwereade: i can't find anything at all. even discussions.
[16:12] <rog> fwereade: (which i find hard to believe - surely people encounter this stuff all the time?)
[16:12] <fwereade> rog, I think the semantics are "you'll get what you're given, and you'll like it"
[16:12] <jimbaker> rog, maybe take a look at http://www.allthingsdistributed.com/ ?
[16:13] <jimbaker> also there is some docs on expected semantics for s3, fwiw
[16:14] <rog> jimbaker: did you have any particular blog post in mind?
[16:14] <fwereade> rog, heh, what if it's just that it's a *really* rare and unreproducible occurrence, so nobody ever hears about it or quite believes it when it happens?
[16:14] <rog> fwereade: it's not rare!
[16:14]  * fwereade dons tinfoil hat
[16:14] <jimbaker> rog, unfortunately no, but it is the sort of thing werner discusses on his blog
[16:14] <rog> fwereade: it happens a lot of the time in my tests
[16:14] <rog> jimbaker: ok, thanks.
[16:14] <fwereade> rog, ah, ok, I didn't realise
[16:15] <rog> fwereade: otherwise i don't think i'd've know
[16:15] <rog> n
[16:43] <rog> fwereade: one minor comment on https://codereview.appspot.com/5672067/
[16:45] <fwereade> rog, not convinced by that; how about a "checkedClock" (or something) field on the type, as a compromise?
[16:46] <rog> fwereade: i'm not sure that's right. if the file did not at first exist, you never need to check the clock.
[16:46] <fwereade> rog, hm, good point
[16:47] <fwereade> rog, Idon;t really like the idea of threading it through all those calls though :/
[16:47] <rog> fwereade: i think that the calls in Alive and AliveW are in the unique position of knowing that the clock needs to be checked, hence my suggestion.
[16:47] <rog> fwereade: it's only two levels...
[16:47]  * fwereade looks at the code again
[16:56] <fwereade> rog, yeah, it turns out ok
[16:56] <rog> fwereade: cool
[16:56] <fwereade> rog, how about calling setAlive setState instead? it now always sets both .alive and .timeout
[16:58]  * rog has a look
[17:01] <rog> fwereade: seems reasonable. (although i think it always has set both alive and timeout)
[17:02] <fwereade> rog, it went through a brief recent incarnation in which it didn't even bother to read the timeout more than once
[17:02] <rog> fwereade: ah
[17:02] <fwereade> rog, changing it back made the name change seem like a good idea
[17:03] <rog> fwereade: yeah, i think setState is a better name for what it does
[17:04] <fwereade> rog, cheers, reproposed ;)
[17:08] <fwereade> rog, EOD I'm afraid; if you have a spare moment I would appreciate it if you would have a little look at https://codereview.appspot.com/5695082 and let me know the perceived crackfulness of the general idea
[17:08] <rog> fwereade: cool!
[17:09] <rog> fwereade: yes, i'll do that
[17:09] <fwereade> rog, er, expect another one in a sec, I appear to have ballsed up a bit
[17:09] <rog> fwereade: looks better with firstTime, to my mind - that logic becomes a bit more obvious.
[17:09] <rog> fwereade: thanks for changing it.
[17:11] <fwereade> rog, a pleasure :)
[17:12] <fwereade> rog, huh, no I didn't balls it up; somehow I was trying to link against something stale, I guess
[17:13] <fwereade> rog, so don't expect an update soon
[17:13] <rog> fwereade: ok. i'll try to ignore the extraneous diffs
[17:14] <rog> fwereade: where's the implementation of relation-get etc again?
[17:14] <fwereade> rog, in python?
[17:14]  * fwereade racks brains
[17:14] <fwereade> rog, juju.hooks.commands
[17:15] <rog> fwereade: no, that wasn't the question.
[17:15] <rog> fwereade: i was wondering what files the new code for " Rough proposal for implementation of relation-get and similar commands." was in
[17:15] <rog> fwereade: presuming it's somewhere in that CL
[17:15] <fwereade> rog, ah sorry: none of them are *implemented* yet
[17:15] <rog> fwereade: server/protocol looks new
[17:16] <fwereade> rog, but it provides a mechanism by which a command like relation-get can get the unit agent (which knows all the appropriate state) to execute the command for it and pipe back the results
[17:16] <rog> fwereade: yeah, that's what i was looking for. that's in cmd/server, right?
[17:17] <fwereade> rog, yeah
[17:18] <rog> fwereade: instant initial reaction: why not use the rpc package?
[17:18] <rog> fwereade: rather than doing our own marshalling etc
[17:18] <fwereade> rog, huh, because I ballsed up on due diligence :p
[17:19] <rog> fwereade: i think this code can be really really small
[17:19] <fwereade> rog, then that's doubly awesome
[17:19] <fwereade> rog, it was very instructive writing it all but less code is always better than more code ;)
[17:19] <rog> fwereade: the unix socket stuff will stay :-)
[17:20] <fwereade> rog, cool
[17:22] <rog> fwereade: but yeah, i think a few methods exported on a relation type and passed to rpc.Server.Register will probably do the job
[17:23] <rog> fwereade: the only thing that won't give you will be commands that stream.
[17:23] <rog> fwereade: are there any like that?
[17:23] <fwereade> fwereade, some certainly dump data back on stdout
[17:24] <fwereade> er, *rog*, ^^
[17:24] <rog> fwereade: lots and lots of data? or don't-care-too-much-if-it's-all-in-memory data?
[17:25] <fwereade> rog, and in general I'd expect/hope that --verbose and --debug should work (and thereby potentially generate monster stderrs too)
[17:25] <fwereade> rog, not sure how big it could get
[17:26] <rog> fwereade: i've an idea for how that could work ok with rpc
[17:27] <fwereade> rog, well, we could do exactly the same in terms of how we pipe stuff back
[17:27] <rog> fwereade: yeah
[17:27] <fwereade> rog, the streams feel to me like a good thing
[17:27] <rog> fwereade: if you're around for a minute or so more, i'll paste a little example
[17:28] <fwereade> rog, please do
[17:31] <rog> fwereade: http://paste.ubuntu.com/860798/
[17:31] <rog> fwereade: slightly contorted by the necessary form of rpc methods
[17:32] <rog> fwereade: but the idea is that you call New which gives you a handle on a running command. then you can call other methods to get info on that command, including reading from its output streams
[17:32] <rog> fwereade: Cmd is the type that would be registered as an rpc handler
[17:33] <rog> fwereade: maybe Cmd.Result might be better named Cmd.Wait
[17:34] <rog> fwereade: and if we were concerned about malicious clients, we could put a random capability string in the Running id.
=== Leseb_ is now known as Leseb
[17:38] <fwereade> rog, seems less clear to me but that's probably a matter of familiarity; I shall meditate upon it
[17:39] <rog> fwereade: i'll quickly sketch an implementation
[17:39] <rog> fwereade: i think it'll be pretty small.
[17:40] <fwereade> rog, don't rush, it has been noticed by others that it's my eod
[17:40] <rog> fwereade: no probs.
[17:40] <rog> fwereade: i've only got 20 minutes myself...
[17:40] <rog> fwereade: see ya tomorrow morning
[17:41] <fwereade> rog, and you :)
[18:39] <andrewsmedina> niemeyer: hi
[18:41] <niemeyer> andrewsmedina: yo
[18:43] <andrewsmedina> niemeyer: for port this test (http://dpaste.org/9MrTY/) I need create another dummy charm?
[18:44] <niemeyer> andrewsmedina: You can copy and change an existing one.. some tests already have the needed utilities to do that easily
[18:45] <niemeyer> andrewsmedina: Hold on.. I'll find an example
[18:46] <andrewsmedina> niemeyer: dont have yet in Go a equivalent for change_sample
[18:46] <niemeyer> andrewsmedina: We actually do
[18:46] <niemeyer> andrewsmedina: Check charm_test.go
[18:47] <niemeyer> andrewsmedina: If you have a reader r, you can do something like
[18:47] <niemeyer> hackYaml := ReadYaml(r)
[18:47] <niemeyer> hackYaml["subordiate"] = true
[18:48] <niemeyer> newr := hackYaml.Reader()
[18:49] <andrewsmedina> niemeyer: I will try this
[18:49] <niemeyer> andrewsmedina: It's not as practical as change_sample yet, but feel free to implement a function so that it is
[18:49] <niemeyer> andrewsmedina: For example: changeSample(func(yh *yamlHacker) { yh["subordinate"] = true })
[18:51] <andrewsmedina> niemeyer: is missing only this use case
[19:07] <niemeyer> Booom!
[19:07] <niemeyer> Summer storm..
[22:39] <andrewsmedina> niemeyer: can you help me?
[22:39] <niemeyer> andrewsmedina: Maybe.. :) What's up?
[22:40] <andrewsmedina> niemeyer: All tests are ok
[22:40] <andrewsmedina> niemeyer: but
[22:42] <andrewsmedina> niemeyer: in python (http://dpaste.org/9MrTY/) when a charm is not a proper subordinate, is returned the charm path in the excetion
[22:47] <hazmat> andrewsmedina, and?
[22:47] <hazmat> this is problematic because?
[22:48] <andrewsmedina> hazmat: I dont have path in go implementation
[22:48] <niemeyer> andrewsmedina: Sounds fine.. just don't return it
[22:49] <andrewsmedina> niemeyer: I return a simple error message?
[22:49] <niemeyer> andrewsmedina: Simplicity FTW
[22:50] <andrewsmedina> niemeyer: I will send the commit in minutes :p
[22:50] <niemeyer> andrewsmedina: Superb :)
[22:50] <andrewsmedina> niemeyer: sorry for my noob questions
[22:50] <niemeyer> andrewsmedina: Totally fine
[22:50] <andrewsmedina> Im a noob in go =/
[22:53] <niemeyer> andrewsmedina: Not to worry.. there are a handful of people only that know Go for more than a couple of years, so you're not too far behind :)