00:00:36  * st_lukejoined
00:04:42  <SubStack>https://github.com/substack/testling-jasmine
00:07:53  <Raynos>dominictarr: why does mdm throw an unexpected disconnection error when I end it?
00:08:01  <Raynos>how am I supposed to get rid of it cleanly?
00:09:04  <dominictarr>well, if the shoe stream ends before the mdm streams end, that is surprising to them.
00:09:17  <dominictarr>you can just ignore it, if you don't care.
00:09:40  <Raynos>dominictarr: but it throws an exception and crashes my server >_<
00:09:41  <dominictarr>maybe I should add an option to disable it though.
00:09:54  <Raynos>whats the correct way to end the shoe stream before the user disconnects
00:10:17  <dominictarr>it emits an error, if you've pipe it to something it will catch it
00:10:27  <dominictarr>no
00:10:49  <Raynos>i agree that the stream closing or getting an error before it ended to be an suprising disconnect
00:10:54  <Raynos>but just an error on its own should be clean
00:10:55  <dominictarr>stream.on('error', function () {})
00:11:08  * devaholicquit (Read error: Operation timed out)
00:11:20  * ryan_stevensquit (Quit: Leaving.)
00:11:31  <dominictarr>what do you mean by 'clean' ?
00:12:00  <Raynos>well if a user disconnects how can I cleanly disconnect the mdm stream on the server
00:12:38  <dominictarr>it will be cleaned up after the error
00:12:43  * mikealjoined
00:12:57  <Raynos>no not that
00:13:00  <Raynos>I dont want the error
00:13:14  <Raynos>its not an unexpected disconnection
00:13:18  <Raynos>its a normal disconnection
00:13:30  <dominictarr>then call end() on the stream.
00:13:31  <Raynos>the fact I have to attach an empty error handler is a dirty hack
00:13:36  <Raynos>how can I call end on the stream
00:14:03  <Raynos>the user closes the tab / window. I cant call end
00:14:04  <dominictarr>i'd take a pull request that added an option to just emit 'end' instead of error.
00:14:22  <dominictarr>that would work fine for message type streams
00:14:28  <Raynos>that could work
00:15:17  <dominictarr>I made it error, because that was more consistent with the way streams work in general.
00:15:45  <dominictarr>that is what would happen if you where streaming something and something killed the wifi
00:17:49  <Raynos>yes
00:17:56  <Raynos>but what if Im streaming something
00:18:00  <Raynos>and someone closes the browser window
00:18:03  <Raynos>or
00:18:08  <Raynos>what if im streaming something
00:18:14  <Raynos>and the user closes the wifi
00:18:16  <Raynos>thats not unexpected
00:22:51  <Raynos>mux-demux reconnection appears to be non trivial :p
00:23:00  <Raynos>Error: does not have stream:885bced74eca7884
00:26:49  <Raynos>dominictarr: I have a single mdm value on the client
00:26:56  <Raynos>when the server goes down and comes back up again
00:27:08  <Raynos>there is another mdm on the server which doesnt have all the stream ids prepopulated
00:27:43  <Raynos>so the mdm on the client is trying to use streams it have with a reconnected server which doesnt know about those ids
00:28:37  <dominictarr>you have to create a new mdm to reconnect.
00:28:50  <dominictarr>like you have to create a new sock object.
00:28:56  <dominictarr>Raynos, ^
00:28:57  <Raynos>dominictarr: -.-
00:30:05  <Raynos>so i have a bunch of code
00:30:12  <Raynos>that is opening a bunch of streams one per room
00:30:21  <Raynos>and your saying that when a reconnect happens I have to destroy all those streams
00:30:26  <Raynos>and swap them out with new ones?
00:30:58  <dominictarr>only the clients that corrispond to one particular client needs to be recreated
00:31:21  <Raynos>but that's a pain in the ass
00:31:30  <Raynos>because there is one underlying shoe connection bus
00:31:40  <Raynos>and a bunch of higher level room based streams on top of that
00:31:57  <Raynos>and the reconnecting of that one stream has to bubble up everywhere to be recreating of all streams
00:32:09  <Raynos>when instead I could just re-use the existing mdm and pipe the new shoe stream into it
00:32:13  <Raynos>why can't I just do that?
00:32:37  <dominictarr>just put it all inside a createStreams function, it would just be like calling it for the first time, only again.
00:33:09  <Raynos>i guess the meta data only needs to be passed once
00:33:26  * devaholicjoined
00:33:29  <dominictarr>what meta data are you passing?
00:33:50  <Raynos>in createStream meta data is passed once
00:33:53  <devaholic>the new fleet hostname stuff is great
00:33:59  <devaholic>just got it updated
00:35:12  <dominictarr>like... user name and stuff?
00:36:56  <Raynos>oh i'm just passing the room name once
00:39:05  <dominictarr>right, I think that makes sense.
00:42:01  * mikealquit (Quit: Leaving.)
00:45:43  <Raynos>I get the infinite write loop again :/
00:45:50  <Raynos>I'm suspecting this might be a bug in mdm
00:46:10  <Raynos>dominictarr: https://gist.github.com/3253104
00:47:24  <dominictarr>are you doing this ps.pipe(mdm).pipe(ps) ?
00:47:55  <Raynos>yes ?
00:48:25  <Raynos>thats to expose a pause stream to the client so that when shoe reconnects i dont kill his stream
00:48:43  <Raynos>its a "proxy" stream in between him and the mdm named stream connection
00:48:48  <dominictarr>pause still pipes through every thing you put into it, when it's not paused.
00:49:18  <Raynos>so thats why its infinite?
00:49:25  <Raynos>i want pause to a bidirectional stream
00:49:31  <Raynos>maybe I should swap it out for through
00:49:35  <dominictarr>because your doing that at both ends?
00:50:14  <Raynos>well I want the writes to mdm to emit data on ps and the writes to ps to emit data on mdm
00:50:18  <Raynos>so I have to do it on both ends?
00:50:18  <dominictarr>you don't need to pause the messages arriving from the server... they need to be paused on the server side.
00:50:50  <Raynos>i need to pause messages going to the server
00:51:01  <Raynos>so when you write messages to the chat when the server is down they are buffered
00:51:19  <dominictarr>okay, so you want to have a stream that is like CHATSTREAM
00:51:26  <Raynos>https://gist.github.com/3c5b26e1921fe4ae44e4
00:51:31  <dominictarr>and you just go CHATSTREAM.write(message)
00:51:36  <Raynos>dnode calls d.pipe(c).pipe(d)
00:51:38  <dominictarr>to say something
00:51:49  <Raynos>but I want CHATSTREAM to be two way
00:51:58  <Raynos>so I can do CHATSTREAM.on("data", renderNewChatMessage)
00:52:05  <dominictarr>yes.
00:52:15  <Raynos>why doesn't dnode's call to d.pipe(c).pipe(d) end in an infinite loop?
00:52:47  <Raynos>is it because the tcp socket is duplex?
00:52:49  <dominictarr>because dnode doesn't pipe events straight through, but pause does.
00:53:00  <dominictarr>both tcp and dnode are duplex.
00:53:06  <Raynos>and pause is through
00:53:06  <Raynos>I see
00:53:15  <Raynos>ok I will just swap pause out for duplex
00:53:16  <dominictarr>exactly.
00:53:40  <dominictarr>you've given me an idea though,
00:53:55  <dominictarr>you are right, the duplex api is ugly.
00:53:56  <Raynos>the fact that there are two types of streams through & duplex is confusing
00:54:12  <Raynos>this is the non-trivial bit for "how streams work"
00:54:24  <dominictarr>I need to draw some ascii art
00:54:58  <dominictarr>diagrams
00:56:27  <Raynos>oh
00:56:28  * ryan_stevensjoined
00:56:33  <Raynos>the duplex stream doesnt flow through >_<
00:57:32  <Raynos>i cant just call pipe on a duplex and expect it to work
00:57:57  <dominictarr>the duplex stream is attached to some other thing.
00:58:39  <dominictarr>the problem is you need to distinguish between a localWrite and a remoteWrite
00:58:53  <rowbit>Hourly usage stats: []
00:58:58  <Raynos>ok when I make the duplex stream write
00:59:02  <Raynos>it goes back into infinite loop mode
00:59:09  <dominictarr>when you call stream.write the stream doesn't know whether that has come from the server, or from the client.
00:59:14  <Raynos>i see your point
00:59:20  <Raynos>I do need to distinquish between a localWrite
00:59:22  <Raynos>and a remoteWrite
00:59:34  <dominictarr>remoteWrite = emitData
01:00:05  <dominictarr>on('reboteData') = on('write')
01:00:47  <Raynos>i see the problem
01:00:49  <Raynos>mdm is not duplex
01:01:01  <Raynos>i want a write to mdm to go to the server
01:01:08  <Raynos>and a emit data on mdm to come from the server
01:01:09  <dominictarr>yup
01:01:29  <Raynos>and then I can close the local loop myself
01:01:38  <Raynos>the mdm stream is a through stream
01:02:01  <Raynos>how do I turn mdm into a duplex stream?
01:02:47  <dominictarr>well, a duplex stream is always hanging off some other appliance
01:02:51  <dominictarr>like dnode
01:03:25  <dominictarr>the thing that consumes the data from the server, and creates data to go to the server
01:03:37  <dominictarr>like a child process.
01:04:00  <Raynos>well I want mdm to be the magic thign
01:04:04  <Raynos>that takes one duplex shoe stream
01:04:09  <Raynos>and gives me a shit ton of duplex streams
01:04:23  <dominictarr>you write to it's input, it does something ... that is pretty much up to it what it does, and then gives you output
01:04:30  <devaholic>not sure of everything you guys are talking about, but if multiple streams worked with dnode along with callbacks and stuff, that would be awesome o/
01:04:53  <dominictarr>devaholic, we're working on it.
01:05:01  <dominictarr>just figuring out how to make it easy.
01:06:02  <Raynos>dominictarr: https://gist.github.com/3253230
01:06:27  <Raynos>devaholic: im working on multiple streams over shoe
01:06:36  <devaholic>seems like you could just write a thing that passes along all the emitter callbacks in a stream through dnode, then somehow multiplex that how mdm works now
01:07:07  <devaholic>might not be the most performant solution but i think it would actually work
01:07:42  <Raynos>devaholic: https://gist.github.com/3253232
01:08:03  <Raynos>it works when you dont try to implement the reconnection logic
01:08:12  <Raynos>the reconnection logic falls over
01:08:44  <devaholic>oo
01:08:52  <dominictarr>Raynos, the through stream diagram is wrong
01:09:36  <Raynos>dominictarr: i thought it might be. but this is how I picture it in my head right now
01:10:27  <devaholic>reconnect in what sense
01:10:43  <Raynos>I see where the loop is coming from
01:12:43  <Raynos>shoe.on("data") -> mdm.write -> getCorrectStream().write -> my code -> my code.on("data") -> correctStream().write() -> mdm.on("data") -> shoe -> server -> shoe.on("data")
01:13:21  <Raynos>dominictarr: is it wrong because remote and local writes are the same thing?
01:17:07  <dominictarr>https://gist.github.com/3253235
01:19:04  <Raynos>how do I solve the problem I have with ps.pipe(mdmStream).pipe(ps)
01:20:17  <dominictarr>your chat application is like dnode.
01:20:35  <dominictarr>it's an appliance that communicates through streams.
01:21:26  <Raynos>yes it is
01:21:47  <dominictarr>chatstream.pipe(ps).pipe(mdmStream).pipe(chatstream)
01:22:01  <dominictarr>chatstream.write = renderMessage
01:22:29  <dominictarr>input.onchange = function (message) { chatstream.emit('data', message}
01:22:36  <Raynos>oh interesting
01:22:56  <Raynos>the chatstream should be duplex
01:23:00  <dominictarr>you need to get INSIDE the stream.
01:23:06  <dominictarr>exactly!
01:23:42  <Raynos>how can .write be render message ?
01:24:18  <Raynos>by that I mean who calls .write to send a message to the server
01:24:31  <dominictarr>pipe calls write
01:24:38  <Raynos>chatstream.on("data", renderMessage), chatstream.write -> to server
01:24:46  <Raynos>i know pipe calls write
01:25:01  <Raynos>but chatstream.pipe(ps) should pipe chat messages to the server
01:25:14  <Raynos>and mdmStream.pipe(chatstream) should call write on chatstream so that i can render
01:25:14  <dominictarr>your chat thing IS the stream.
01:25:48  <dominictarr>so if you are a stream, and you have something to say, you emit data.
01:26:14  <dominictarr>when someone tells you something, they write it to you.
01:26:15  <Raynos>oh interesting
01:26:22  <Raynos>thats how it works
01:26:36  <Raynos>but then when I want to tell someone else something I call write
01:27:01  * mikealjoined
01:27:13  <dominictarr>so like, in dnode, when dnode is telling the other side that you are calling a remote function
01:27:31  <dominictarr>it would be like dnodestream.emit('data', HEY CALL THE FUNCTION)
01:27:54  <dominictarr>pipe passes that to write on the tcp stream
01:28:20  <dominictarr>which emits data on the other end, which then writes it to the OTHER dnode.
01:29:18  <dominictarr>who calls the function and then emits data HEY THIS IS THE RESULT and the same thing happens again, but back the other way this time.
01:29:51  <Raynos>dominictarr: https://gist.github.com/3253320
01:30:09  <Raynos>i think the trick is seperate read & write streams
01:30:22  <Raynos>and then passing a duplex of just those two back to the thing that uses the abstraction
01:32:50  <dominictarr>yup, that also works.
01:34:12  <Raynos>this is good I now understand what's going on
01:34:19  <Raynos>it also kills my circular reference
01:34:33  <Raynos>or not :D
01:35:53  <devaholic>hmm ive gotten a `conn is not defined` error in propagit a few times running fleet ps
01:41:37  <Raynos>well my code stopped crashing with errors :P
01:50:06  <Raynos>I now have a bug where writes come through after disconnection but reads dont come through
01:52:34  <dominictarr>Raynos, mdm emits data after it's disconnected?
01:52:49  <Raynos>no my reconnection logic does
01:52:55  <dominictarr>ah.
01:53:26  <Raynos>dominictarr: https://gist.github.com/87e8cd478290560827b7
01:53:29  <Raynos>what do you use instead?
01:58:05  <dominictarr>I saw this today http://github.com/mixu/minilog
01:58:25  <dominictarr>I just use console.log, usually.
01:58:52  <rowbit>Hourly usage stats: []
02:03:21  * ryan_stevensquit (Quit: Leaving.)
02:16:36  <Raynos>I have this streaming code : https://gist.github.com/0eccf4ca6a163a450d2d
02:16:44  <Raynos>on every connect an extra write gets logged
02:16:52  <Raynos>however the number of reads getting logged dont increases
02:16:56  <Raynos>which is weird
02:17:26  <devaholic>dominictarr: the streaming aspect is neat
02:17:35  <devaholic>dominictarr: i use rconsole though!
02:26:09  <Raynos>is there an unpipe?
02:27:13  * mikealquit (Quit: Leaving.)
02:30:13  * ryan_stevensjoined
02:36:57  <dominictarr>Raynos, short answer...
02:37:12  <dominictarr>but it's looking like there might be one in 0.9
02:40:33  <Raynos>well its more about cleanup for me
02:40:47  <Raynos>im pipiing a write stream into this pipe that is a connection to a server
02:40:59  <Raynos>and then im piping the same write stream into a new pipe which is a reconnection to the server
02:41:03  <Raynos>and want to unpipe the old one
02:41:05  <Raynos>for cleanup
02:41:12  <Raynos>because node bitches about the 11 event listeners
02:44:19  * mikealjoined
02:47:30  <dominictarr>Raynos, I have a pull request out for this at the moment.
02:48:14  <dominictarr>you could do it a hacky way, by listening to newListener and grabbing the cleanup listener that pipe assigns and then calling that...
02:48:33  <dominictarr>or monkeypatching Stream.
02:49:09  <Raynos>well I want to get reconnecting working first
02:49:10  <Raynos>cleanup second
02:49:17  <dominictarr>Stream is not gonna change in 0.8 so it's not the worst idea ever
02:49:18  <Raynos>did you see the gist above
02:49:24  <Raynos>it hits the logger but doesnt hit the read stream
02:49:27  <Raynos>with is epic wtf
02:58:15  <dominictarr>aha!
02:58:17  <dominictarr>I see it.
02:58:19  * captain_morganquit (Remote host closed the connection)
02:58:37  <dominictarr>you've forgotten something
02:58:52  <rowbit>Hourly usage stats: []
02:59:02  <dominictarr>it's the sort of thing that creates epic wtf when you leave it out.
02:59:33  <dominictarr>I'm guessing that is what it is anyway.
03:01:26  <dominictarr>Raynos, oh... no... you just copied a little bit of the code... maybe you didn't leave off a var
03:03:57  <Raynos>dominictarr: ?
03:04:02  <Raynos>dominictarr: ? where is the bug
03:04:35  <Raynos>dominictarr: the lack of var is on purpose
03:05:58  <isaacs>capslockscript is fantastic
03:06:45  <SubStack>isaacs: kickban konobi
03:06:51  <SubStack>HE IS NOT LOUD ENOUGH
03:06:52  <LOUDBOT>ACHIEVEMENT UNLOCKED: FUCK A STAB WOUND
03:07:10  <isaacs>SubStack: konobi is a wise one of the perl ages
03:07:18  <isaacs>SubStack: we must show respect.
03:08:45  <isaacs> /kick is one thing, but /ban is excessive
03:09:34  <SubStack>VERY WELL
03:09:35  <LOUDBOT>THAT THING
03:11:28  <Raynos>SubStack: you still on 16th & dolores?
03:11:37  <SubStack>17th yeah
03:12:11  <Raynos>i may come hang
03:12:13  <Raynos>im round the corner
03:29:34  * SubStackchillin like a villain
03:29:57  <SubStack>a chillanous villain that is
03:30:01  <SubStack>like mr freeze
03:34:39  <Raynos>dominictarr: https://github.com/dominictarr/mux-demux/pull/3
03:36:38  <dominictarr>Raynos, can you add a bit about the option to the readme?
03:38:35  <Raynos>dominictarr: done
03:46:25  <dominictarr>...and PUSHED
03:47:16  <dominictarr>mux
03:47:27  <dominictarr>-demux@1.1.0
03:48:45  <SubStack>Raynos: they close in 10 mins I guess
03:48:53  <SubStack>so heading out
03:48:57  <Raynos>got destracted coding
03:48:59  <SubStack>back to oak city
03:49:01  <Raynos>you can code here if you want
03:52:38  <Raynos>dominictarr: https://github.com/Raynos/mux-demux-shoe
03:52:40  <Raynos>one piece of the puzzle
03:52:53  <devaholic>hmm, i cant run fleet monitor from two places at the same time
03:53:51  <dominictarr>Raynos, you some sort of pun on some sort of multi part shoe
03:58:52  <rowbit>Hourly usage stats: []
04:13:02  * dominictarrchanged nick to dominictarr[havi
04:13:11  * dominictarr[havichanged nick to dominictarr[nap]
04:23:24  * ryan_stevensquit (Quit: Leaving.)
04:37:53  * ryan_stevensjoined
04:58:35  <Raynos>dominictarr: https://gist.github.com/3254631
04:58:38  <Raynos>using a duplex stream fails
04:58:42  <Raynos>using seperate write & read works
04:58:53  <rowbit>Hourly usage stats: []
05:00:07  <devaholic>mm
05:00:18  <devaholic>i got most of the fleet stuff working in the browser, but stop wont work :(
05:05:27  <Raynos>devaholic: what do you mean in the browser?
05:08:19  <SubStack>devaholic: stop is kind of broken, perhaps it's not the browser at fault?
05:09:08  <devaholic>it seems to ask for too much info
05:09:16  <devaholic>well the other stuff works
05:09:23  <devaholic>ill put it on gh in a bit
05:09:33  <devaholic>Raynos: monitor, fleet process list, etc, in a dashboard
05:09:46  <Raynos>devaholic: we want to build that dashboard. make it open sauce!
05:10:06  <devaholic>Raynos: i have wanted to build it for a while xd
05:10:20  <devaholic>i will in a bit! going for a drink now
05:15:09  <SubStack>nice!
05:36:49  * ircretaryjoined
05:55:09  <Nexxy>SubStack, are you available for a quick dnode question?
05:58:53  <rowbit>Hourly usage stats: []
06:01:41  <Raynos>Reconnection works!
06:01:48  <Raynos>I mean almost. sock is ugly when it reconnects
06:02:19  <SubStack>Nexxy: beep boop
06:05:26  <Raynos>SubStack: https://github.com/Raynos/boot#boot
06:05:49  <Raynos>SubStack: I really want to use yarnify without the build step somehow :(
06:17:52  <SubStack>what about --watch?
06:26:10  <Raynos>SubStack: does that exist ?
06:26:25  <Raynos>I was thinking of adding `.yarn` as a file extension that browserify recognises
06:39:41  * mikealquit (Quit: Leaving.)
06:45:18  <SubStack>could work
06:48:22  * mikealjoined
06:51:47  * ryan_stevensquit (Quit: Leaving.)
06:55:14  <Raynos>SubStack: how do I hook into the types of files browserify recognises?
06:56:10  <Raynos>SubStack: I would wrap.register, now how do I register something asynchronous like yarnify?
06:58:52  <rowbit>Hourly usage stats: []
07:01:56  * stlsaintquit (Quit: leaving)
07:32:39  * xaqjoined
07:33:03  <Raynos>SubStack: A watch system should be good enough for now with yarnify. Ideally I need some way to hook it into browserify
07:36:39  <SubStack>watching is implemented with register in browserify
07:37:08  <Raynos>interesting
07:37:16  <Raynos>register still assumes a synchronous filter
07:37:22  <Raynos>and has no support for async filters
07:40:57  <SubStack>true
07:41:03  <Raynos>dominictarr: https://github.com/Raynos/stream-chat/blob/master/client/index.js#L17 thanks for the insight that the chat app should be a stream
07:42:36  <Raynos>SubStack: how do you do bidirectional upnodes ?
07:43:31  <SubStack>how do you mean bidirectional?
07:43:51  <SubStack>each side pings the other one but you can't get away from the fact that only one of the sides can initiate connections
07:46:36  <Raynos>SubStack: I want to use the up function in the client and the server
07:46:45  <Raynos>Maybe that's just badc
07:47:15  <Raynos>SubStack: Can you expose the stream hooks in upnode in airport?
07:58:53  <rowbit>Hourly usage stats: []
07:59:12  <SubStack>which hooks?
08:13:54  * ryanseddonjoined
08:23:23  <devaholic>does upnode work in browsers?
08:31:55  <SubStack>Raynos is working on something like that
08:54:01  <Raynos>devaholic: https://github.com/Raynos/seaport-proxy
08:54:19  <Raynos>devaholic: I can write a demo of upnode in browsers using boot
08:55:49  <Raynos>SubStack: the thing that allows me to pass in createStream to airport
08:58:53  <rowbit>Hourly usage stats: []
09:00:54  <Raynos>devaholic: https://github.com/Raynos/boot/tree/master/example/upnode cc: SubStack
09:01:21  <Raynos>SubStack: if you let me pass createStream into airport I'll make airport work in the browser
09:09:42  <SubStack>sweet!
09:12:15  <Raynos>i made another pass at seaport-proxy
09:12:19  <Raynos>couldnt get it to damn work
09:21:05  <devaholic>npm install -g fleet-panel && fleet-panel
09:21:11  <devaholic>https://github.com/tblobaum/fleet-panel
09:21:47  <devaholic>adding the cl options made me wish i could parse fleet.json more easily
09:23:03  <devaholic>oh bleh, the account url should be configurable
09:23:48  <devaholic>you can link to your commits/repos on github
09:24:43  <Raynos>tblobaum: nice first steps
09:27:51  <devaholic>get it working?
09:28:57  <SubStack>O_O
09:29:22  <SubStack>yeah the fleet index.js needs parity with the commands so you can drive it programmatically
09:29:44  <SubStack>even though most of the code lives in propagit
09:30:58  <devaholic>the stop works now btw
09:32:34  <SubStack>testing it with my test-cluster
09:35:11  <Raynos>i have it kind of working locally
09:35:14  <Raynos>it doesnt auto refresh
09:35:22  <devaholic>some of the code isnt incredibly efficient, an innerHTML call especially, because i was lazy
09:36:00  <devaholic>Raynos: when is it not refreshing?
09:36:13  <Raynos>i spawn a new process thing
09:36:15  <SubStack>yeah the refreshes stopped here too
09:36:16  <Raynos>and it doesnt show me
09:36:18  <SubStack>worked when I restarted
09:37:15  <devaholic>my browser lagged a bit when the scrollbacks got really long, was that happening?
09:37:46  <Raynos>it doesnt do much
09:37:53  <SubStack>pretty sweet!
09:38:24  <devaholic>its a process list + monitor + stop and some linkage to github
09:38:49  <devaholic>oh and it works on your phone
09:39:39  <devaholic>but if the list isnt refreshing when it should, i want to fix that
09:39:52  <Raynos>ill play with it some more later
09:39:56  <SubStack>likewise
09:40:09  <SubStack>I want to make a network graph tab for it
09:40:39  <devaholic>its pretty easy to see dying processes
09:40:51  <SubStack>yeah dying processes thrash a ton
09:40:57  <devaholic>which i found useful, because sometimes its not apparent a process is respawning like crazy without fleet monitor
09:41:16  <devaholic>also killing lots of stuff is easy
09:41:29  <SubStack>I often forget to `fleet exec --drone=* -- npm rebuild` after I deploy
09:41:47  <devaholic>i really dont like having to run npm rebuild
09:41:51  <SubStack>would be nice to have automatic hooks in fleet.json for that like Raynos was saying
09:42:53  <SubStack>and the status could be set to something special while those initialization scripts run
09:44:30  <devaholic>btw Raynos if you run fleet monitor somewhere it stops any other fleet monitors, that would make it stop refreshing
09:45:03  <devaholic>SubStack: yeah statuses gave me some ideas!
09:47:40  <devaholic>also perhaps storing commands so they can be run in the browser
09:48:27  <guybrush>i have a "crashed" count in ps with nexus, that proved handy
09:54:34  <SubStack>devaholic: it'd be neat if fleet-panel could read the git log somehow
09:54:46  <SubStack>I should expose that as a function you can call in the fleet hub
09:58:52  <rowbit>Hourly usage stats: []
10:04:03  <devaholic>hmm
10:05:10  <SubStack>need to write up a proposal for node dublin
10:05:34  <SubStack>wondering which libs to talk about or something completely different
10:09:20  <devaholic>git log --pretty=format:'[ "%h", "%d%s", "%cr", "%an" ]' --abbrev-commit
10:10:05  <devaholic>git log --pretty=format:'[ "%h", "%d%s", "%cr", "%an" ],' --abbrev-commit
10:10:06  <devaholic>better
10:10:13  <devaholic>going to dublin? thats awesome
10:13:56  <devaholic>git log --pretty=format:'[ "%H", "%s", "%cr", "%an" ],' --abbrev-commit
10:58:52  <rowbit>Hourly usage stats: []
11:15:41  * captain_morganjoined
11:22:21  * captain_morganquit (Remote host closed the connection)
11:27:54  * dominictarr[nap]changed nick to dominictarr
11:58:52  <rowbit>Hourly usage stats: []
12:04:31  * devaholicquit (Ping timeout: 240 seconds)
12:10:24  * captain_morganjoined
12:12:38  * devaholicjoined
12:35:26  * captain_morganquit (Remote host closed the connection)
12:37:46  <SubStack>isaacs: I miss the counter with that total number of packages on npmjs.org
12:38:02  <SubStack>might send a pull req
12:49:57  <dominictarr>carmak makes a very good point at 30:30 ... for a few minutes...
12:58:53  <rowbit>Hourly usage stats: []
13:58:53  <rowbit>Hourly usage stats: []
14:38:52  * saijanai_quit (Quit: saijanai_)
14:58:53  <rowbit>Hourly usage stats: []
15:27:21  * captain_morganjoined
15:58:52  <rowbit>Hourly usage stats: []
16:31:52  * stlsaintjoined
16:58:53  <rowbit>Hourly usage stats: []
17:24:28  * AvianFlujoined
17:25:57  <isaacs>SubStack: yeah, that'd be rad.
17:27:18  <isaacs>SubStack: pretty easy to do. add a models/registry-root.js or something that hits npm.registry.get('/') every so often (sort of like the browse.js model)
17:27:35  <isaacs>SubStack: and then have the routes/index.js depend on that, and the templates/index.js can decide how to display it
17:28:59  <isaacs>SubStack: note that you have to subtract 4 from the doc_count to account for the _design docs
17:29:04  <isaacs>er, 3 i mean
17:29:32  * isaacsjust deleted _design/ui
17:58:53  <rowbit>Hourly usage stats: []
18:30:20  * mikealquit (Quit: Leaving.)
18:33:28  * mikealjoined
18:54:34  * saijanai_joined
18:55:43  * mikealquit (Quit: Leaving.)
18:58:53  <rowbit>Hourly usage stats: []
19:02:19  * mikealjoined
19:17:35  * mikealquit (Quit: Leaving.)
19:27:19  * Dr_Kjoined
19:32:09  * AvianFluquit (Quit: Leaving)
19:52:00  * devaholicquit (Ping timeout: 264 seconds)
19:58:53  <rowbit>Daily usage stats: []
19:58:53  <rowbit>Hourly usage stats: []
20:18:30  * mikealjoined
20:58:53  <rowbit>Hourly usage stats: []
21:08:47  <Raynos>SubStack: Talk about hw awesome the new testling your writing is going to be :P
21:17:54  * AvianFlujoined
21:26:01  <Raynos>SubStack: an interesting talk would be how you keep all your processes up and how you monitor. Which is different from how seaport & fleet allow you to spawn shit ton of processes
21:26:11  <Raynos>SubStack: another interesting talk is dont build big apps ever
21:27:15  <Raynos>SubStack: "10 things you don't expect me to do with AST parsing"
21:29:19  * stlsaintquit (Quit: leaving)
21:36:22  <Raynos>SubStack: `var b = browserify({ debug: true, longStackTraces: true })`
21:36:43  <Raynos>how do I do AST magickery to make long stack traces just work in the browser (can be chrome only)
21:53:29  * mikealquit (Quit: Leaving.)
21:56:48  * stlsaintjoined
21:58:53  <rowbit>Hourly usage stats: []
22:18:32  * stlsaintquit (Read error: Operation timed out)
22:33:42  * xaqquit (Remote host closed the connection)
22:40:41  * xaqjoined
22:58:52  <rowbit>Hourly usage stats: []
23:03:30  <SubStack>Raynos: these are all excellent ideas
23:19:49  * mikealjoined
23:58:52  <rowbit>Hourly usage stats: []