=== sadmac_ is now known as sadmac === magnetic is now known as foolano [18:23] notting: read my blog? [18:24] saw it. have not looked at the code. [18:24] cool [19:08] ion_: I wrote a new allocator over the weekend ;) [19:09] Ooo [19:09] Keybuk: get my email? [19:09] sadmac2: yes. I still think your state machine is crazy [19:10] ion_: nih_alloc and nih_free still work as before (alloc with parent, free anyway) [19:10] but now you have nih_alloc_ref (add a new parent), nih_alloc_unref (drop a parent) and nih_discard (throw away only if there are no parents) [19:10] Keybuk: and I still haven't seen you propose a mechanism behind that pretty syntax of yours [19:10] keybuk: Alright [19:10] keybuk: Does unref automatically discard? [19:11] ion_: yes [19:11] sadmac2: err, I've told you exactly what I'm going to do - it hasn't changed since plumbers [19:12] Keybuk: really? because I haven't read about it the same way twice [19:12] depsolving keeps disappearing and reappearing... [19:12] "depsolving" ? [19:12] if you start foo, which depends on bar, does it start both or just error and tell the user "Fix it?" I've heard you tell it both ways [19:13] no you haven't [19:14] there was an auto keyword at plumbers [19:14] that vanished last time we spoke [19:16] err, that vanished after a lengthy debate both on the mailing list and on here [19:17] must've missed it here. Dunno where it was on the mailing list [19:17] "upstart configuration", Nov 2008 [19:18] ah, so its add a manual now [19:18] no [19:18] the functionality is still there then [19:19] it's treat disabling jobs as a separate thing to their definition [19:19] a sysadmin can flag a job as disabled [19:19] bit more like SMF [19:19] I ran it by our server team here, their eyes lit up with joy, so it's a keeper [19:21] ok, so the fundamental difference is in your system states/jobs are first class objects [19:21] where my system essentially doesn't have a first class object [19:23] can you solve all the use cases with yours? mounting? (dbus I know you've done) [19:23] I suspect that leads to a lot of differences, both fundamental and trivial [19:23] I'm fairly certain yours could be implemented on top of mine (not that we should, but its very significant that we can). [19:23] stateless mounting still can't be solved in yours, so I don't see that to be a useful example [19:24] can you mount at all? [19:24] can you manage the state for stateful mounting? [19:24] yes, of course [19:24] 0.5 can't do /either/ that's the importance of the case [19:25] I can manage the state for stateful mounting without Upstart at all [19:25] just by using udev and some shell scripts [19:25] so I'm not sure that's a useful example either [19:25] I don't know that you can easily express virtual states either (explanation follows): [19:26] so my usecase would be SELinux [19:26] its damn useful to know if the system is enforcing or not and act based on this. [19:26] you can check if the system is enforcing by running getenforce [19:27] but its hard to get an event stream from which you can derive it [19:27] in my model its not hard to describe states coming from anywhere. so you could define: [19:27] selinux: test-by /usr/bin/getenforce [19:28] and it would run that how many times a second? [19:28] Keybuk: it would run it when it needed to know. When the user lists states or when dependency checking is interested in the selinux state [19:28] the rest of the time selinux would be neither up nor down [19:29] its "quantum." neither running nor not running until observed [19:29] it needs to know continually [19:29] otherwise how would it know when to stop a service because selinux is no longer being enforced? [19:30] also would it only check that if a sysadmin issues a start command? [19:30] otherwise when would it check that for other reasons? [19:30] when the service came up [19:30] Keybuk: and this can be used in combination with regular ons and when (event1..event2) [19:31] how can the service come up if it's waiting on a dependency using test-by? [19:32] Keybuk: if there's an exec stanza, then it goes by the usual method (it can verify the test after execing, or not, that's a bit more of a philisophical question) [19:33] sorry [19:33] but it sounds like you really haven't thought this through [19:33] since you're not bothering to answer the question [19:34] Keybuk: on setenforce(1)..until setenforce(0) [19:35] Keybuk: the events can still stop it [19:35] ok, let's do a worked example [19:35] Keybuk: /but/ we don't get the initial setenforce, because its done in initrd (and there be pjones) [19:35] give me a real example of a service that would depend on selinux in this fashion [19:35] so the additional test-by is necessary [19:36] Keybuk: setroubleshootd [19:36] no, that runs in permissive too. If we had one for "disabled" then that works [19:36] ok, let's use setroubleshootd for a moment [19:37] how would its definition be expressed? [19:37] setroubleshootd when selinux [19:37] no : s ? [19:37] no paths or arguments ? [19:38] that's just the setroubleshootd ->selinux dep [19:38] setroubleshootd has no other dependencies (not even filesystem writable or mounted?) [19:38] please don't shorthand [19:38] give the full example [19:38] use pastebin if you like [19:38] setroubleshootd [19:38] when selinux [19:39] when can-exec("/usr/bin/selinux") [19:39] exec /usr/bin/selinux [19:40] can-exec test-by [ -x %1 ] [19:40] selinux [19:40] test-by getenforce [19:40] when (setenforce(1)..setenforce(0)) [19:40] #eof [19:40] ok [19:40] now give me a worked example of a system boot [19:40] it's just come up [19:40] Upstart has started [19:40] now what happens? [19:41] well, assumedly it parses the job definitions [19:41] so let's say it's done that [19:41] now what? [19:41] shit. missing a line [19:42] can-exec when mounted [19:42] ^^for efficiency. not mandatory [19:42] you haven't defined mounted in the above, so please do that [19:42] (feel free to just claim it's a state that comes up at some useful point) [19:43] Keybuk: its a state that comes up whenever a filesystem is mounted. [19:43] what brings that state up? [19:43] I think if you're going to rely on such a thing right now, you need to define it ;) [19:43] it might be easier for your example just to assume that there's only one filesystem and no such state [19:44] yeah, ignore that. there's some particulars to this stage of boot I'm not thinking of [19:44] ok, so we're up [19:45] ok [19:45] so we're up [19:45] what happens now? [19:47] we trip an initial event, say startup. [19:47] this triggers a whole bunch of states not relevant to this example. [19:47] perhaps [19:47] though that event is not referenced in your above example [19:47] so let's ignore it [19:48] ok. [19:48] upstart has started, it has parsed its configuration, what happens next? [19:49] it triggers some state which wants setroubleshootd [19:49] setroubleshootd in turn wants selinux [19:49] selinux was enabled with setenforce, but this happened in initrd, so we don't know [19:49] this being a fresh boot, the state is indeterminate, so we run test-by [19:50] getenforce tells us selinux is up. we clear that dependency for selinux' [19:50] can-exec is never triggered by anything but the test-by. [19:50] so we run the test stanza there [19:51] it tells us we are allowed to execute /usr/sbin/selinux. [19:51] */usr/bin/setroubleshoot [19:52] we bring the state tentatively up, and tell the service manager to run /usr/bin/setroubleshoot [19:52] it returns a service handle, which we add to our parameters, and come all the way up [19:54] this triggers a netsplit [20:11] wb [20:11] this triggers a whole bunch of states not relevant to this example. [20:11] so let's ignore them [20:11] your example is all that interests me [20:11] and it is self-contained [20:11] it makes no reference to other events, or other states [20:11] upstart has started, it has parsed its configuration, what happens next? [20:11] -- [20:11] that's as far as things got before the split [20:16] Keybuk: ok, what'd we collectively miss? === sadmac_ is now known as sadmac [20:18] wb [20:18] this triggers a whole bunch of states not relevant to this example. [20:18] so let's ignore them [20:18] your example is all that interests me [20:18] and it is self-contained [20:18] it makes no reference to other events, or other states [20:18] upstart has started, it has parsed its configuration, what happens next? [20:18] -- [20:18] that's as far as things got before the split [20:18] --> sadmac_ (n=sadmac@nat/redhat/x-6753e36432a1150f) has joined #upstart [20:20] Keybuk: ok, well, we need one more state: running_normal [20:20] Keybuk: it has lots and lots and lots of deps. one of them is setroubleshoot [20:21] a goal state [20:21] if you so please [20:21] one that lists the services that should be running in normal configuration? [20:21] yes [20:21] I consider this a failure [20:22] if we're going to have goals, let's just use initng [20:22] umm, what? [20:22] why? [20:23] the reasons I wrote Upstart, instead of just modifying something that already exists, is that I expressly did not want goals, runlevels, or anything similar [20:23] it's the _only_ difference between Upstart and those other systems [20:23] Keybuk: and its the _most_ requested feature I get from people [20:23] then those people should use initng or launchd or smf [20:23] Keybuk: the advantage here is 1) goals aren't mutualy exclusive [20:23] they aren't mutually exclusive in initng either [20:24] 2) goals are named, and there are infinitely many [20:24] they are named in initng [20:24] 3) they can be expressed in terms of each other [20:24] goals in initng can depend on each other [20:24] Keybuk: ok, how do I start a predefined subset of my usual services from the command line? [20:24] in initng? ngc start wibble I think [20:25] it's been a while since I played with it [20:25] in upstart [20:26] in my plan for Upstart ? [20:26] yes [20:26] start my-predefined-subset-of-my-usual-services [20:26] which is a file that looks something like: [20:26] while service1 and service2 and service3 [20:26] a goal state [20:26] you can also just do: [20:26] start service1 [20:26] start service2 [20:26] start service3 [20:26] and that has the same effect [20:26] no, it's not a goal [20:26] a set of goal states [20:27] yes it is [20:27] no, it really isn't [20:27] why not? [20:28] let's put this discussion on abeyance for a moment [20:28] and go back to your example [20:28] setroubleshootd [20:28] when selinux [20:28] when can-exec("/usr/bin/selinux") [20:28] exec /usr/bin/selinux [20:28] can-exec test-by [ -x %1 ] [20:28] selinux [20:28] test-by getenforce [20:28] when (setenforce(1)..setenforce(0)) [20:28] that is what you defined [20:28] and upstart has started, has parsed its configuration, and is now waiting [20:28] what happens next? [20:29] it knows its supposed to start running_normal (from other configuration, kernel cmdline, your pick) [20:29] and so it does, and it depsolves it as it starts it [20:29] running_normal isn't defined above [20:29] so please, again, do not reference anything outside your example [20:29] I defined it as I came in [20:29] in syntax.. [20:30] running_normal: [20:30] when setroubleshoot [20:30] ok [20:30] when [20:30] upstart is waiting [20:30] what tells it to start "running_normal"? [20:30] what tells it to start "setroubleshootd"? [20:30] what tells it to start "selinux?" [20:31] upstart's first action on running is always to start some kind of "strap state" which in our case is configured (one way or another) as running_normal [20:31] ok [20:31] that is what I call a "goal" [20:31] it does a solve-and-start on the strap state [20:31] goal, strap state, runlevel, etc. [20:31] ok [20:31] upstart has a predefined state it tries to reach [20:31] I'm not disputing its a goal [20:31] this state is defined as a series of dependencies [20:32] to reach it, it solves the dependency set, starting each service in term [20:32] perhaps applying some kind of ordering to that [20:32] congratulations, you've designed a dependency-based init daemon [20:32] http://initng.org/ - enjoy ;P [20:32] Keybuk: what of this strategy are you escaping with upstart? [20:33] Upstart, in its very original definition, is an event-based system [20:33] not a dependency-based system [20:33] which is broken [20:33] from the very first document I wrote on the subject, I outlined this as the distinction between Upstart and what else exists out there today [20:34] if that is broken, then Upstart is a failed project and should be abandoned [20:34] our efforts would be better spent on the pre-existing dependency based init daemons [20:34] what are we changing then? [20:34] (if you consider that not broken) [20:34] what does your plan do that is not a goal? [20:35] if you truly believe that Upstart, as an event-based init daemon, is broken [20:35] and you believe that a dependency-based init daemon works, then you should look into one of the dependency-based daemons [20:35] initng is the prime example here [20:35] if the licence isn't a problem, SMF might be appealing - though it isn't as flexible [20:35] ok [20:36] but how is an event based init daemon /that solves the problems in 0.5/ still different? [20:38] the difference between the two can be defined quite simply [20:38] a dependency-based init daemon knows where it's going, and figures out how to get there [20:38] an event-based init daemon has no idea, and just does whatever it can [20:39] ok, I see your problem. let me adjust my example [20:39] to setroubleshoot add: [20:39] when running_normal [20:39] auto [20:40] (the auto is an artifact of the present syntax. It can be massaged out) [20:40] and delete running_normal's definition altogether [20:40] same result [20:40] actually, that's better [20:40] now there's no depsolving in standard boot [20:40] so let's go back to the same worked example [20:41] upstart has parsed its configuration [20:41] what does it do next? [20:41] well, it marks running_normal as up, by config. This is now just a marker though. It has no deps [20:42] a ground state? [20:42] ie. replace startup with a state? [20:42] yes [20:42] (would just "on startup" not be a valid example there?) [20:43] ok. I think in the long run this way is better for a few reasons, but sure. [20:43] running_normal on startup [20:43] that fulfills one of setroubleshootd's when clauses [20:43] but not the other [20:43] sorry, not the other TWO [20:44] it has a dep on the can-exec("/usr/sbin/selinux") state [20:44] and the selinux state itself [20:44] and it doesn't /trigger/ it, let's go into that for a second and then we'll look at those [20:44] so running normal comes up. [20:45] as upstart finishes doing this, it adds an event to the event queue: trigger-auto-services [20:45] this causes setroubleshootd to be brought into question [20:46] upstart iterates through setroubleshootd's deps. theres running_normal. that's satisfied. [20:46] there's can_exec. upstart looks at the can_exec state and sees that it is undetermined and has a test_by [20:47] it runs the test by and finds that /usr/bin/setroubleshootd is accessible [20:47] so can_exec is up [20:47] note that it does not /come/ up [20:47] it /is/ up [20:47] upstart just didn't know it before :) [20:47] selinux is much the same way. its test_by is run and it is determined to be up. [20:48] for the sake of argument [20:48] setroubleshootd's when's now satisfied, it leaps upward [20:48] let's say that selinux is not up [20:48] the test-by fails [20:48] test-by fails, selinux remains undetermined, and no setroubleshootd [20:49] /now/ [20:49] suppose we added this line to our config [20:49] no [20:49] no changing things [20:49] setroubleshootd didn't come up on boot [20:49] fine [20:50] the sysadmin notices that, and realises that selinux wasn't enabled [20:50] and enables selinux [20:50] what happens now? [20:50] nothing [20:50] no [20:51] selinux had 2 lines of config [20:51] nothing tells your system to re-evaluate its test-by clauses [20:51] look at number 2 [20:51] and let me elaborate [20:51] when (setenforce(1)..setenforce(0)) [20:51] the sysadmin brings up selinux [20:51] you didn't define setenforce in your example, so I ignored it [20:53] you didn't mention this hypothetical appendix in your example [20:53] err [20:53] so I didn't elaborate on the mechanisms that would make that case work [20:53] the whole point of working an example is to find out what happens ;) [20:53] no, I /know/ what happens [20:53] that means working through all the cases [20:53] the point is to tell you [20:54] ok, we'll define setenforce [20:54] setenforce, through whatever syntax is defined on inotify noticing a change in /selinux/enforcing [20:54] (yes, said file supports inotify) [20:55] it is emitted with one argument: the contents of that file. [20:56] * sadmac needs selinux auto [20:56] yeah, I'll work on getting the auto thing out of the syntax [20:56] its kinda a pain [20:57] so the sysadmin changes enforcing, and this satisfies selinux's one and only when clause [20:58] from here there's a couple things it could do, and I'm flexible as to which: [20:58] we could re-run the test-by to be sure (not certain I like that) [20:58] this is my fundamental issue with test-by [20:59] you have to re-run it periodically [20:59] or, and this is my assumption, we simply jump right up. once up, if we are configured with a debug flag, we run the test clause, and if it disagrees with what we just did, we through -EDUMBASS [20:59] Keybuk: but we've run it exactly 2 times now, both times deterministically [21:00] no interval timer yet [21:00] Keybuk: the other thing is even if its unreliable it can still be useful in some form. for example [21:00] mount(type: nfs, host: *) [21:00] when network-up(%host) [21:01] network-up test-by ping %host [21:01] even the ingrained unreliabilities there are better than we could do otherwise. [21:02] when it fails due to insufficient repitition the mount just takes longer to timeout [21:02] when it works though we have a bit more verification and probably a quicker abort, [21:08] to be fair, I should give how I'd do it [21:08] I'm not familar with selinux, but judging above the above [21:08] selinux would look like: [21:08] pre-start exec getenforce || setenforce [21:08] post-stop exec setenforce 0 [21:09] -- [21:09] setroubleshootd would look like: [21:09] while selinux [21:09] exec /usr/sbin/selinux [21:09] the worked example would be [21:09] upstart parses its configuration [21:09] the selinux job has no while condition, so can be immediately started [21:09] if selinux was enabled already, getenforce would succeed so the state would be up [21:10] if selinux was not enabled already, getenforce would fail, so setenforce is run and the state would be up [21:10] (it setenforce failed, then selinux would be down) [21:10] selinux coming up fulfills the while condition for setroubleshootd [21:10] so that would exec /usr/sbin/selinux and come up [21:10] what if sbin isn't mounted [21:11] no need for any startup event or ground state, etc. [21:11] you mean /usr ;-) [21:11] Keybuk: you've known saner storage admins than me I gues [21:11] s [21:11] :P [21:11] /sbin cannot be on a separate filesystem [21:11] it contains init [21:12] anyway [21:12] now, the above has a slight disadvantage in that it requires you to not use setenforce directly, but instead use "stop selinux" or "start selinux" as the commands [21:12] that in of itself isn't insane, but it's maybe annoying to experienced sysadmins [21:12] I'd solve that the same way you would [21:12] redefine selinux in terms of the contents of /selinux/enforcing [21:13] that might be something like [21:13] while file-contains /selinux/enforcing 1 [21:13] where file-contains was a built-in that used inotify [21:13] you've mostly talked me out of test-by [21:15] barring that then, what else is different between the mechanisms? [21:16] syntax is somewhat an artifact and somewhat not. I don't care about the syntax but the differences in mine are an artifact of it doing things yours doesn't [21:16] the fact that everything my way is first class [21:16] and it's massively simpler to understand [21:17] not really [21:17] I'll go back to what I said months ago [21:17] when I figured it out [21:17] foo(bar: baz) == all foos with bar = baz have these properties: [21:17] yours can be summed up as [21:17] : [21:17] ie. when the state on the left is true, the actions on the right are performed [21:18] no [21:18] that's very wrong [21:18] because there are no actions [21:18] that's how you defined it yourself not so long ago ;) [21:18] its declarative, and its backward [21:18]