[03:02] <Keybuk> hmm, momentary thoughts on bug tracking
[03:02] <Keybuk> is "logd not working" a bug?
[03:03] <Keybuk> or is it simply wishlist
[03:03] <Jc2k> is it a regression?
[03:03] <Jc2k> if it never worked, its a wishlist IMO
[03:03] <Keybuk> it worked once, then we disabled it
[03:03] <Keybuk> the reason I wonder is that the "triaged" state doesn't make sense for it
[03:03] <Jc2k> urrrgh
[03:04] <Keybuk> (or some of the other bugs in there)
[03:04] <Keybuk> Confirmed - there's enough information to replicate the bu
[03:04] <Keybuk> Triaged - there's enough information to fix the bug
[03:04] <Keybuk> but for things like that, neither makes sense
[03:04] <Keybuk> which is why I wonder whether it's a wishlist
[03:05] <Jc2k> its a regression so in one sense its a bug. but its not really fatal to anything so more of a wishlist item..
[03:05] <Keybuk> yeah, tricky innit
[03:06] <Jc2k> aye
[03:06] <Jc2k> toss a coin?
[03:06] <Jc2k> heads its a wishlist
[03:06] <Jc2k> ;)
[03:07] <Jc2k> had any more upstart related thoughtlets?
[03:09] <Keybuk> not yet
[03:11] <Jc2k> im not sure what to do for my needs :(
[03:12] <Keybuk> what were those again?
[03:13] <Jc2k> one example is for syncing windows mobile devices
[03:13] <Jc2k> synce.org has a couple of daemon type progs it needs
[03:13] <Jc2k> i dont really like the idea of them running constantly
[03:13] <Jc2k> so wanted to try using hal events to start them
[03:14] <Jc2k> i had been thinking hal -> upstart
[03:18] <Jc2k> on top of that, there are quite a few devices that need you to ppp them before they are useful. network manager could be used for that in the future, but i dont know how far off such things are...
[03:23] <Keybuk> ah yes, I remember
[03:26] <Keybuk> months off, at least
[03:37] <Jc2k> ideally i'd like to have this stuff auto-magicked by then
[03:37] <Jc2k> i think the guy i was talking to on ubuntu-devel-discuss was hoping to have something pretty for HH...
[03:38] <Keybuk> oh, who was that?
[03:39] <Jc2k> i think Martin Owens
[03:40] <Jc2k> we had cultural differences between yorkshire and liverpool..
[03:40] <Jc2k> :)
[03:41] <Keybuk> the sync project stuff?
[03:44] <Jc2k> aye
[03:45] <Keybuk> yeah, there's a few people working on that for 8.04
[03:47] <Jc2k> nice that they are getting in touch...
[03:47] <Keybuk> how do you mean?
[03:48] <Jc2k> i've not heard anything from martin or anyone else and theres been no mention of it on ubuntu dd
[03:48] <Keybuk> wouldn't be yet
[03:48] <Keybuk> we're still in the 7.10 release cycle
[03:48] <Jc2k> ahh
[03:48] <Keybuk> 8.04 doesn't begin for another couple of weeks
[03:49] <Jc2k> i know that theres a RH guy really interested in Conduit, so i was hoping to get a bit of cross-distro love
[03:49] <Jc2k> but i really want some flashy "here i am plugging in my phone and it just working" demo before i go pimping again! :)
[03:50] <Keybuk> the trouble with cross-distro love is that the distros don't tend to love each other ;)
[03:50] <Jc2k> aye :(
[03:51] <Jc2k> i'll love the distro that loves me i guess
[03:52] <Jc2k> unfortunately there arent any local (at least inside UK) get togethers i know of in the near term where I can pimp Conduit and/or get help with the fiddly polishy bits needed to support some of the devices we want to support
[03:53] <Jc2k> i think the nearest is going to be, ironic as its so far, linux conf au
[03:53] <Jc2k> or lug radio us
[04:16] <Jc2k> Keybuk: think i'm going to resort to "pupstart" unless you have any ideas.
[04:16] <Jc2k> i.e. a subset of upstart in python solely focused on my simple needs
[04:17] <Keybuk> init can't be written in Python
[04:17] <Keybuk> you'll end up with a machine full of zombie processes, and a non-functioning init :p
[04:17] <Keybuk> (not without rewriting the C bits of Python, anyway)
[04:18] <Jc2k> eh
[04:18] <Jc2k> it wouldnt be init
[04:19] <Keybuk> what would it be then?
[04:19] <Jc2k> some event -> start a program, some event -> stop a program
[04:19] <Jc2k> primarily hal events
[04:20] <Keybuk> if it's not an init daemon, please don't call it "upstart" or anything even similar
[04:20] <Jc2k> and able to deal with multiple copies of same programs
[04:20] <Keybuk> otherwise that will just confuse people
[04:20] <Jc2k> ok
[04:20] <Keybuk> you already have that though -- it's called D-BUS :p
[04:20] <Jc2k> eh
[04:20] <Jc2k> really?
[04:21] <Keybuk> that does most of it already
[04:21] <Jc2k> do i have to add dbus to everything though
[04:21] <Keybuk> probably
[04:21] <Keybuk> this is not a bad thing
[04:22] <Jc2k> alas a bit much for my weak C skills
[04:22] <Jc2k> might be doable for the synce case though
[04:23] <ion_> Perhaps gutsy just contains too old versions of opensync and conduit, but i dont seem to be able to sync two evolutions over the network using either one. :-\
[04:24] <Keybuk>    conduit |    0.3.2-1 | http://gb.archive.ubuntu.com gutsy/universe Packages
[04:24] <Jc2k> i wet myself when i made the video.
[04:24] <Keybuk>   opensync | 0.19-1.2ubuntu1 | http://gb.archive.ubuntu.com gutsy/main Sources
[04:24] <ion_> (d be nice if conduit and opensync were integrated somehow, btw.)
[04:24] <Jc2k> its *really* sweet
[04:24] <Jc2k> conduit is up to 0.3.4
[04:24] <Jc2k> the network sync hasn't been released, you need to run svn
[04:25] <Jc2k> opensync, 0.19 is ancient.
[04:25] <Jc2k> ion_: i'm working to let opensync be used from conduit
[04:25] <ion_> Nice
[04:25] <Keybuk> nothing newer in Debian
[04:25] <Jc2k> atm i am able to use opensync plugins in conduit
[04:25] <Jc2k> and hoping to support multiple sync engines soon too
[04:26] <Jc2k> meant to be going to germany to collaborate with them soon
[04:27] <Jc2k> anyway, if there are any conduit questions im happy to answer on #conduit (GIMPnet), but back on topic
[04:28] <Jc2k> doing this all in dbus has implications on the scope of upstart?
[04:28] <Jc2k> e.g. equally some of boot up (sh/w)ould be handled by the dbus system activation patches?
[04:29] <Keybuk> yes
[04:30] <Keybuk> in a 100% new-world desktop, the only init supervised services would be udev/hal, d-bus and gdm
[04:30] <Keybuk> (though that ignores things like mounting filesystems, etc. - but then RH have a single shell script for all that)
[04:30] <Jc2k> what about crashes
[04:31] <Jc2k> should some of these dbus triggered services self-heal or just wait to be needed
[04:31] <Keybuk> who knows
[04:31] <Jc2k> :)
[04:31] <Keybuk> this is why Upstart development has stalled for a while
[04:31] <Keybuk> figuring out how it fits in
[04:32] <Jc2k> the thing i still dont understand in the new-world desktop is how services die.
[04:32] <Jc2k> i want things to go away..
[04:34] <Keybuk> I think we have to consider D-BUS signals a key part of the system
[04:34] <Keybuk> which means that they need to be able to start and stop processes on their own
[04:35] <Keybuk> it makes sense to have a ServiceManager daemon that handles this
[04:35] <Keybuk> which makes room for Upstart
[04:35] <Keybuk> (it then makes sense for D-BUS and HAL to use that ServiceManager for their own activation purposes)
[04:35] <Keybuk> the difficulty comes in two stages:
[04:35] <Keybuk>  1) how are D-BUS signals captured, and converted into useful environment for the service being started
[04:35] <Keybuk>  2) what about events that aren't D-BUS signals yet?
[04:37] <Jc2k> it depends on what information will be needed for (2), but from the outsider position wrapper seems doable to inject faux dbus signals
[04:37] <Keybuk> the annoying thing is how hard D-BUS signals are to define
[04:37] <Jc2k> aye
[04:38] <Jc2k> perhaps the hal path, key, value approach would work?
[04:39] <Jc2k> the signal would always be a path, key and value
[04:39] <Jc2k> or perhaps a list of
[04:39] <Keybuk> The DpmsModeChanged signal in the org.gnome.PowerManager interface emitted from the /org/gnome/PowerManager object by the org.gnome.PowerManager service
[04:40] <Jc2k> i was thinking we'd be able to control all the signals, but of course we might want to respond to other signals
[04:40] <Keybuk> (and that's for objects you can name!  You can't reliably name objects from HAL!)
[04:40] <Jc2k> so artificially restricting the kinds of signals that are interesting is not possible...
[04:41] <Keybuk> yeah
[04:41] <Jc2k> is dbus introspectable enough from C land that we could have a FDI-alike?
[04:42] <Keybuk> yes
[04:42] <Keybuk> but then we're in FDI hell
[04:42] <Jc2k> with great power comes great pains in the butt
[04:42] <Keybuk> and sometimes a signal is just a signal
[04:42] <Keybuk> and contains no useful information
[04:43] <Keybuk> you need to make an object call to obtain the information about the signal
[04:43] <Jc2k> and at this point we have a desire for a minimal scripting language
[04:44] <Jc2k> and the equal opposite desire for fear of the untold danger involved in such a thing
[04:44] <Keybuk> so you can see why this needs careful thought :p
[04:44] <Jc2k> indeed.
[04:44] <Jc2k> hopefully pestering you will help you decide whats best ;)
[04:45] <Keybuk> heh
[04:45] <Keybuk> I haven't had time to sit down and understand D-BUS
[04:45] <Keybuk> and more particularly, how it's used
[04:46] <Keybuk> if I had a list of the signals, methods, etc. that all the usual desktop bits generated, then I would have a better idea
[04:46] <Keybuk> since that would infer what to listen for
[04:46] <Jc2k> eh
[04:46] <Jc2k> i've tried to understand it
[04:47] <Jc2k> and i hurted :P
[04:47] <Jc2k> the current case seems to be that the initial uses of dbus were a bit crap and not how the API was intended to be used
[04:47] <Jc2k> but that this is improving
[04:48] <Keybuk> yeah
[04:48] <Keybuk> but they won't drop them :p
[04:48] <Jc2k> :p
[05:22] <Jc2k> i had an idea
[05:22] <Jc2k> then i tried to replay it in my head
[05:22] <Jc2k> and forgot the best bit
[05:22] <Jc2k> -_-
[05:22] <Jc2k> i hate jet lag
 15:17:12> +init can't be written in Python
 15:17:25> +you'll end up with a machine full of zombie processes, and a non-functioning init :p
[05:22] <AlexExtreme> ^^ pardus wrote their init in python ;)
[05:23] <Jc2k> AlexExtreme: i knew there was one distro that did, forgot its name.. thx
[05:23] <Jc2k> wait
[05:23] <AlexExtreme> although, it's rather buggy :P
[05:24] <Jc2k> AlexExtreme: have i seen you in #ylug or #lugradio at all?
[05:24] <AlexExtreme> I don't think so
[05:24] <AlexExtreme> at least, I don't remember ever being in either of those
[05:24] <Jc2k> hmmm
[05:24] <Jc2k> its going to bother me now :)
[05:25] <Keybuk> AlexExtreme: heh
[05:25] <Keybuk> the Python problem is that it doesn't handle signals properly
[05:25] <Keybuk> it handles them well enough for user space
[05:25] <Keybuk> but init has different signal semantics
[05:26] <AlexExtreme> yes
[05:28] <Jc2k> i was thinking along the lines of mapping the entire boot sequence and saying which things belonged to dbus activation and which things still need init and any other categories along the way
[05:29] <Jc2k> i was also thinking that this whole stalemate is because of the big picture
[05:29] <Jc2k> trying to make sure upstart is ready for everything, without even knowing what everything is
[05:31] <Jc2k> on the python thing
[05:32] <Jc2k> could init be chained?
[05:32] <Jc2k> as in, the actual init just starts a python init which is then "orginary"
[05:32] <Jc2k> perhaps the "raw" upstart has the service start/stop api
[05:33] <Jc2k> e.g. org.something.ServiceManager
[05:33] <Jc2k> and then python pokes the other services
[05:34] <Keybuk> the python init is still not ordinary
[05:34] <Keybuk> since it's still pid #1
[05:34] <Jc2k> eh
[05:35] <Keybuk> unless the python process was forked
[05:35] <Keybuk> in which case, you lose the special powers you get as pid #1
[05:35] <Keybuk> which are the reason to be pid #1 in the first place
[05:35] <Jc2k> i was going for making the special powers to be dbus exposed
[05:35] <Keybuk> splitting Upstart into a ServiceManager component and a ServiceActivator component has been discussed
[05:35] <Keybuk> the thought was that /sbin/init would be pid #1
[05:36] <Keybuk> and would expose the org.freedesktop.ServiceManager interface
[05:36] <Keybuk> and then you'd start other things that used that interface to start and stop processes
[05:36] <Keybuk> though it's not clear how you handle blocking in that scenario
[05:36] <Keybuk> (where when you start apache, it blocks waiting for other services to start first)
[05:38] <Jc2k> and presumably in that case the ServiceActivator is "normal"?
[05:39] <Jc2k> dont really grok the apache case. are you saying that apache shouldnt start until other things are ready, or that other things shouldnt start until apache is ready?
[05:40] <Keybuk> both
[05:40] <Amaranth> Jc2k: Both
[05:40] <Amaranth> heh
[05:40] <Keybuk> if you've got tomcat installed, it should be started if apache is starting
[05:41] <Keybuk> and apache should wait until tomcat is started before continuing
[05:41] <Jc2k> how is that handled in the current case? the init script doesnt exit until apache is ready?
[05:41] <Jc2k> sorry for nub questions btw
[05:41] <Keybuk> current case?
[05:42] <Jc2k> as in, why does moving to ServiceManager  ServiceActivator make this different?
[05:42] <Jc2k> presumably ServiceManager can just issue a signal when a process is loaded?
[05:43] <Jc2k> kind of like Twisted has Defer's
[05:43] <Keybuk> but then ServiceManager has to block :)
[05:43] <Keybuk> ie. when does it decide to carry on
[05:43] <Jc2k> when the signal fires?
[05:44] <Jc2k> i imagine it would be painful in C land, but twisted python is pretty good at pausing where its at until a signal completes
[05:45] <Keybuk> but D-BUS has no notion of signal completion
[05:45] <Keybuk> it'd actually need to be a method
[05:45] <Keybuk> which is somewhat kooky, since who is the method against?
[05:45] <Amaranth> or fire a 'finished' signal
[05:45] <Jc2k> maybe "completes" was a bad choice
[05:46] <Jc2k> i call StartProcess and then attach to a signal called ProcessStarted
[05:47] <Jc2k> also dbus does have a way to specify a function to call when the method completes
[05:47] <Jc2k> so you can StartProcess(some, params, reply_handler=self.Started_Cb)
[05:47] <Jc2k> where self is an object containing enough info to carry on
[05:48] <Keybuk> err?
[05:48] <Keybuk> sorry, not following
[05:48] <Jc2k> 1s
[05:59] <Jc2k> Keybuk: http://pastebin.com/d80f7e06 <- make any sense?
[06:00] <Jc2k> aside from the fact that its not even close to valid python...
[06:03] <Amaranth> it's pretty close :)
[06:03] <Jc2k> Amaranth: i puked when i re-read it.
[06:10] <Keybuk> Jc2k: the problem is, how does the StupidManager send out the message that the job is starting
[06:10] <Keybuk> and thereby give other processes the option to handle that message, and delay the starting of the job
[06:10] <Amaranth> oh, uh, ouch
[06:12] <Jc2k> Keybuk: i guess that such delays should be handled before you go to ServiceManager
[06:12] <Jc2k> ?
[06:14] <Jc2k> actually no
[06:15] <Jc2k> so theres a difference between the Apache job and the apache process?
[06:15] <Keybuk> dunno
[06:15] <Jc2k> you start ./apache and ./tomcot before  the apache "job" is ready
[06:15] <Jc2k> *tomcat even
[06:21] <Jc2k> Keybuk: are you going to be near IRC tonight?
[06:21] <Keybuk> yeah probably
[06:21] <Jc2k> okies
[06:22] <Jc2k> i have to commute for a bit now, so i'll think about another version of my pastebin 
[06:22] <Jc2k> it will treat a job as something different from a process
[06:22] <Jc2k> which i think is the key to it satisfy your needs
[06:40] <Keybuk> interesting
[06:40] <Keybuk> so GNOME Power Manager is entirely implemented through HAL D-BUS stuff
[06:41] <Keybuk> signal sender=:1.10 -> dest=(null destination) path=/org/freedesktop/PowerManagement; interface=org.freedesktop.PowerManagement; member=OnBatteryChanged
[06:41] <Keybuk>    boolean false
[06:42] <Keybuk> actually, sorry, that's wrong
[06:42] <Keybuk> since that's not coming from HAL
[06:42] <Keybuk> even though the docs say it will
[06:46] <Keybuk> GNOME developers should be banned from uploading anything without docs
[06:47] <Keybuk> (says the author of the most undocumented init system there is :p)
[06:56] <ion_> :-)
[06:57] <Keybuk> though I'm making some kind of process
[06:58] <Keybuk> e.g. "running while a battery is present"
[06:59] <Keybuk> => listen to HAL for DeviceAdded/DeviceRemoved signals, take the object path and then check for the "battery" capability, it has it, check the "battery.present" property is "true"
[07:00] <Keybuk> (also obviously listen for changes to that property, as well as the NewCapability signal in case some existing object becomes a battery)
[07:01] <Keybuk> so this requires a combination of method calls and signals
[07:06] <Keybuk> this strongly implies the need for upstart-addon-hal
[07:10] <Keybuk> likewise similar for avahi
[07:10] <Keybuk> since for that you need a ServiceBrowser for each thing you want to watch for
[09:11] <Jc2k> Keybuk: still not grokking the big problem
[09:12] <Keybuk> it's quite complex to explain :-/
[09:12] <Jc2k> tell me about it
[09:12] <Jc2k> i feel like im missing something obvious
[09:13] <Jc2k> before upstart i implemented an event based job manager for my old company
[09:13] <Jc2k> events were simpler there
[09:13] <Jc2k> timer events, file change events and "job x finished" events
[09:13] <Jc2k> each job was dependant on multiple events
[09:14] <Jc2k> and then i had a set of god awful queries to work out which jobs were due to run
[09:14] <Keybuk> right
[09:14] <Jc2k> that could handle all kinds of edge cases
[09:14] <Keybuk> it's the god awful bit that causes us issues
[09:14] <Jc2k> well in my case, the god awful came from having to build it out of ms access and vbscript :P
[09:14] <Keybuk> heh
[09:15] <Keybuk> ok, let me try and quickly explain
[09:15] <Keybuk> jobs can be manually or automatically started and stopped
[09:15] <Keybuk> manual is by initctl, automatic is by events
[09:15] <Keybuk> jobs also generate events themselves
[09:15] <Keybuk> four of them
[09:15] <Keybuk>  starting = I'm about to start, but nothing has been run yet
[09:15] <Keybuk>  started = I'm now running and ready for action
[09:16] <Keybuk>  stopping = I'm about to stop, but nothing has been killed yet
[09:16] <Keybuk>  stopped = I'm no longer running
[09:16] <Keybuk> thus the events that jobs can be automatically started/stopped by aren't just external forces like battery status, but can also be based on other jobs
[09:16] <Keybuk> so if HAL depends on D-BUS, it can be started by the "started dbus" event and stopped by the "stopping dbus" event
[09:17] <Keybuk> that way HAL is never running when d-bus isn't
[09:17] <Jc2k> grokking so far
[09:17] <Keybuk> events in Upstart have the notion of completion
[09:17] <Keybuk> initctl emit foo will actually wait until that event emission has completed
[09:17] <Keybuk> the completion of an event is when all jobs that reacted to it have reached their goal state
[09:17] <Keybuk> (running for services, stopped again for tasks)
[09:18] <Keybuk> so if I have a service that's started "on foo", "initctl emit foo" will actually show the progress of that service, and not return until that service is running
[09:18] <Keybuk> this means events also have failure
[09:18] <Keybuk> if that service fails to start, initctl emit foo will actually exit 1
[09:18] <Keybuk> (if no services are affected by the event, the event completes immediately)
[09:19] <Keybuk> ok?
[09:19] <Jc2k> grokking :)
[09:19] <Jc2k> good so far
[09:19] <Keybuk> right
[09:20] <Keybuk> so upstart uses this event completion internally for the starting and stopping job events
[09:20] <Keybuk> when the service emits the starting event, it will not proceed until the starting event has completed
[09:20] <Keybuk> likewise for the stopping event
[09:20] <Keybuk> so if I have a small task that's run "on stopping mysql" (e.g. to backup the database), mysql *will not be stopped* until that task completes
[09:21] <Keybuk> since services only need to reach running or stopped, this also provides upstart's dependency mechanism
[09:21] <Jc2k> so even though mysqld isnt running, the mysql "job" is still "stopping"
[09:21] <Keybuk> no
[09:21] <Keybuk> mysqld *IS* running
[09:21] <Keybuk> upstart hasn't killed it yet
[09:21] <Jc2k> ahh
[09:21] <Jc2k> ok
[09:22] <Keybuk> (or it might not be, if mysqld died, but that's a different story :p)
[09:22] <Jc2k> lol
[09:22] <Keybuk> the event does actually tell you why mysql is stopping
[09:22] <Keybuk> on stopping mysql failed main
[09:22] <Keybuk>   EXIT_SIGNAL=SEGV
[09:22] <Keybuk> for example
[09:23] <Keybuk> anyway, digressing
[09:23] <Keybuk> since services only need to reach running or stopping, this provides Upstart's dependency system
[09:23] <Keybuk> the tomcat server, if installed, is a dependency of Apache
[09:23] <Keybuk> (web sites use it)
[09:23] <Keybuk> so the tomcat job can specify:
[09:23] <Keybuk>   start on starting apache
[09:23] <Keybuk>   stop on stopped apache
[09:24] <Keybuk> now, if you "start apache" the following will happen:
[09:24] <Keybuk> the apache job emits the starting apache event
[09:24] <Keybuk> which starts the tomcat job (event is now blocked)
[09:24] <Keybuk> the tomcat job issues starting tomcat, runs its various scripts, and eventually the tomcat daemon is running
[09:24] <Keybuk> tomcat job emits started tomcat
[09:24] <Keybuk> and the event is now unblocked
[09:24] <Keybuk> and thus the event completes
[09:24] <Keybuk> apache can now start, run its various scripts, and the httpd daemon
[09:25] <Keybuk> so the tomcat job, by being started when apache is starting (rather than started) can make itself a dependency of apache
[09:25] <Keybuk> (and rather usefully, it becomes tied to the lifecyle of apache - you don't have to think of it as a separate service)
[09:26] <Jc2k> got it
[09:27] <Jc2k> so with start on starting apache we make sure tomcat starts before apache
[09:27] <Keybuk> exactly
[09:27] <Jc2k> so i cant actually do my python demo without mixing in dependencies
[09:27] <Keybuk> this is the bit that's hard to implement with a separated service manager and automation manager core
[09:28] <Keybuk> since the service manager needs to be able to block the service on things that the automation manager knows
[09:29] <Jc2k> i still think i can do it with async dbus
[09:29] <Jc2k> though i worry i missed something
[09:29] <Keybuk> the problem with dbus is that you need to specify someone to ask :)
[09:29] <Keybuk> signals have no completion
[09:29] <Keybuk> so the starting/stopping events can't be signals
[09:29] <Keybuk> (we'd never know whether something cared)
[09:29] <Keybuk> they have to be methods
[09:29] <Keybuk> and you can't have an open method
[09:29] <Keybuk> you have to know who you're asking
[09:30] <Keybuk> at which point, why have two processes since they're inherently coupled anyway?
[09:30] <Jc2k> are we saying that the problem is that when ServiceManager raises a signal you no longer know what that signal is about?
[09:31] <Keybuk> no
[09:31] <Keybuk> that it doesn't know whether anyone cared about the signal
[09:31] <Keybuk> or whether those who cared about the signal did anything about it
[09:31] <Jc2k> this is the bit where i dont get it :)
[09:32] <Jc2k> im ok up to where i said "i worry i missed something"
[09:32] <Jc2k> then my world fell apart
[09:32] <Keybuk> heh
[09:32] <Keybuk> which bit don't you get?
[09:32] <Keybuk> you understand how Upstart events work wrt completion?>
[09:33] <Jc2k> apache is starting, but tomcat has to start first, so tomcat starts. apache is still in the starting state until tomcat is started.. then apache finishes starting and it is started...
[09:33] <Jc2k> all that stuff makes sense
[09:34] <Keybuk> right
[09:34] <Jc2k> i dont understand how it breaks down when the service is split in 2
[09:34] <Jc2k> i dont understand what is lost
[09:35] <Keybuk> the way that events work :)
[09:35] <Keybuk> because D-BUS doesn't support that at all
[09:36] <Jc2k> i see that it doesnt support that natively
[09:36] <Keybuk> exactly
[09:36] <Keybuk> you can't use signals to do it
[09:36] <Keybuk> you have to use methods
[09:36] <Keybuk> does that make sense?
[09:37] <Jc2k> but most of the state should be in the automation manager..
[09:37] <Jc2k> if i can prototype it, you buy me beer?
[09:37] <Keybuk> :)
[09:37] <Keybuk> sure
[09:37] <Keybuk> does it make sense that you can't use D-BUS signals?
[09:37] <Keybuk> because they are fire-and-forget
[09:38] <Jc2k> kind of
[09:38] <Jc2k> im going to try to use async method calls first
[09:39] <Keybuk> so the problem with method calls is that, in D-BUS, you must know your target
[09:39] <Keybuk> I can't tell the world that a job is starting
[09:39] <Keybuk> I can only tell one person
[09:39] <Keybuk> (I can tell the world with signals, but I cannot find out whether the world cared)
[09:40] <Keybuk> with a method, I can tell one person, and they can give me a result
[09:40] <Keybuk> but I have to hard-code that one person
[09:40] <Jc2k> right
[09:40] <Jc2k> now i understand.
[09:40] <Jc2k> and i scratch my freshly shaved beard.
[09:41] <Jc2k> but...
[09:41] <Keybuk> so since the service manager would have the name of the policy bit hard-coded
[09:41] <Keybuk> why have them separate at all? :p
[09:41] <Jc2k> no.
[09:41] <Jc2k> brain failing... holding on to thread of something...
[09:41] <Jc2k> i think we are talking about different services
[09:42] <Jc2k> in my mind i was assuming that pid 1 *soley* starts and stops single processes
[09:42] <Jc2k> but in actual fact
[09:42] <Jc2k> pid 1 starts and stops jobs
[09:42] <Jc2k> which is why the dependency stuff comes in and starts being awkward
[09:43] <Jc2k> in my mind i was thinking that was in pid 2 or wherever, hence why i didnt grok that there would be a problem
[09:44] <Jc2k> so essentially dbus sucks because you can ask it to do something, it can poke you and tell you something happened but it can't poke you and ask you a question
[09:45] <Jc2k> Keybuk: did that make sense?
[09:46] <Keybuk> yup that makes sense
[09:46] <Keybuk> I don't think you need to separate processes and jobs?
[09:46] <Jc2k> no, i just misunderstood a key point :P
[09:47] <Jc2k> i still have an idea, but i want to have a play with it first.
[09:49] <Keybuk> ok
[09:53] <Jc2k> the basic idea is to flip it around and have things that are interested in events expose an interface of their own
[09:54] <Jc2k> so signal Announce from org,frestuff,EventListener at /org/freestuff/EventListener/<some_uid>
[09:54] <Jc2k> that interface would allow events to block
[09:54] <Jc2k> but though it works
[09:54] <Jc2k> its still messy
[09:55] <Jc2k> hmm