Pyogp/Chat Logs/Daily Meeting/06 Aug 2008

* [9:34] Infinity Linden: the login stuff i did relied about zero on the spec
* [9:34] Connected undefined: 
* [9:34] Enus Linden: the gridnauts huddle should finish in a sec...
* [9:34] Infinity Linden: and all on peeking inside the SSL sessions between client and server
* [9:34] Enus Linden: sneak :)
* [9:34] Infinity Linden: yeah.
* [9:34] Infinity Linden: that's me
* [9:34] Infinity Linden: but
* [9:34] Saijanai Kuhn: morning
* [9:35] Enus Linden: i think i just need to throw what i have over the fence and let others take it at this point
* [9:35] Infinity Linden: the great thing about root access is you get to open /dev/mem and see what's there
* [9:35] Enus Linden: i have exceeded my 'facilitator' role lately
* [9:35] Saijanai Kuhn: I used SL proxy too
* [9:35] Enus Linden: hi Sai
* [9:35] Infinity Linden: yeah... i think Tess and Zero and I are about there with respcet tot he spec
* [9:35] Infinity Linden: hola Sai
* [9:35] Saijanai Kuhn: hilo
* [9:35] Infinity Linden: eek. this Proxy thing that folk are talking about
* [9:35] Tao Takashi: Hi
* [9:36] Enus Linden: mornin Tao
* [9:36] Enus Linden: well, afternoon
* [9:36] Infinity Linden: this is undoubtedly one of the things i miss out about by not showing up at the 9am meeting
* [9:36] Infinity Linden: i really have to shake loose my other commitments and start making it to that meeting
* [9:36] Saijanai Kuhn: SL proxy won't work with the new login/tp though. Which is why we need to make a pyogp proxy available
* [9:36] Tao Takashi: you are talking about Gareth's stuff?
* [9:37] Saijanai Kuhn: no, just SL proxy
* [9:37] Saijanai Kuhn: or at least I was
* [9:37] Tao Takashi: ah, ic
* [9:37] Infinity Linden: honestly... last couple of days i've been so far down the security and authentication rabbit hole, I know nothing about the proxy
* [9:37] Saijanai Kuhn: though, I think your pyogp Agent DOmain could do what Garteth's stuff does anyway
* [9:38] Tao Takashi: to me it wasn't too clear what he was doing actually ;-)
* [9:38] Tao Takashi: I thought it's a proxy in front of a region
* [9:38] Tao Takashi: but I was also a bit under workload
* [9:38] Bartholomew Kleiber: does it proxy name/pwd :-/ ?
* [9:38] Tao Takashi: so I haven't looked to closely
* [9:38] Saijanai Kuhn: eh, from what I goathered he was intercepting the OGP calls to the sim and routing them to an unmodded sim
* [9:38] Infinity Linden: hmm.. no Lock yet
* [9:39] Infinity Linden: oh oh
* [9:39] Tao Takashi: yeah, that's what I understood
* [9:39] Enus Linden: i just pinged him in irc
* [9:39] Infinity Linden: that's vaguely cool, i suppose
* [9:39] Enus Linden: lock is incoming
* [9:39] Tao Takashi: so yes, I guess you can say that it to some extent simulates an AD
* [9:39] Infinity Linden: in theory... we'er all going to be running OGP in 18 months
* [9:39] Saijanai Kuhn: well its hte simplest way to implement OGP. I'm not convinced it will work for anything beyond login/tp though
* [9:40] Tao Takashi: I guess it somehow can be done, not sure it makes sense though ;-)
* [9:40] Infinity Linden: there will be some relatively dire consequences for even the open community if we all have to speak the legacy protocol to each other
* [9:41] Infinity Linden: but yeah.. .as long as the unmodded sim doesn't speak directly to other sims and ADs
* [9:41] Enus Linden: hi Lock
* [9:41] Locklainn Linden: hey everyone
* [9:41] Enus Linden: so let's huddle
* [9:41] Locklainn Linden: sorry, forgot
* [9:41] Tao Takashi: Hi Lock
* [9:41] Enus Linden: i'll start
* [9:41] Tao Takashi: tztz ,-)
* [9:41] Locklainn Linden: :)
* [9:41] Enus Linden: i've worked on interop tests lately
* [9:41] Infinity Linden: 'k... lest go
* [9:41] Enus Linden: today i will finish what i want to have done
* [9:41] Infinity Linden: cool
* [9:41] Infinity Linden: lets go
* [9:41] Enus Linden: some tests are thorough
* [9:41] Enus Linden: others are incomplete
* [9:42] Infinity Linden: so you're gonna check them in this afternoon / evening?
* [9:42] Enus Linden: but the framework is there and functional
* [9:42] Enus Linden: i will infinity
* [9:42] Enus Linden: i've paid more attention to caps testing than to login e.g.
* [9:42] Infinity Linden: so
* [9:42] Infinity Linden: uh
* [9:42] Infinity Linden: what tests are you working on?
* [9:42] Enus Linden: teleport and derez testing await locklainn's udp work
* [9:42] Enus Linden: i have done: rez_avatar/request, rez, place
* [9:42] Enus Linden: derez is stubbed out
* [9:42] Enus Linden: login is there to a degree
* [9:42] Enus Linden: but way too basic there
* [9:43] Enus Linden: i've just kind of reached my limits for now with how much time i can spend
* [9:43] Infinity Linden: okay
* [9:43] Enus Linden: so i hope to recruit others via whuimps office hours today
* [9:43] Infinity Linden: cool
* [9:43] Enus Linden: i will check in and update wiki today
* [9:43] Enus Linden: next....
* [9:43] Infinity Linden: were you able to make heads or tails of the stuff i sent you?
* [9:43] Locklainn Linden: awesome
* [9:44] Enus Linden: i was infinity
* [9:44] Infinity Linden: yeah
* [9:44] Enus Linden: though, you asked me to hold off with it
* [9:44] Infinity Linden: i guess i missed the bit about us using the config package we're using
* [9:44] Infinity Linden: so
* [9:44] Infinity Linden: all my tools currently use XML
* [9:44] Infinity Linden: so
* [9:44] Enus Linden: should i still hold off, or look into integrating it?
* [9:45] Enus Linden: there can be different data handling methods for now if needed
* [9:45] Infinity Linden: well... it is the framework for what we want to test
* [9:45] Enus Linden: though, ultimately, 1 would be best
* [9:45] Infinity Linden: right now the only thing i;m interested in is running tests that hit our implementation
* [9:45] Enus Linden: Configparser can move to your method down the road if it is better
* [9:46] Enus Linden: right
* [9:46] Infinity Linden: no
* [9:46] Infinity Linden: we've made the decision to use configparser
* [9:46] Infinity Linden: we need to start keeping some things constant
* [9:46] Locklainn Linden: we did? :)
* [9:46] Infinity Linden: yes
* [9:46] Infinity Linden: it's documented in the wiki
* [9:46] Locklainn Linden: oh ok
* [9:46] Saijanai Kuhn: makes a note
* [9:46] Locklainn Linden: must have missed it
* [9:46] Infinity Linden: yeah... i missed it too
* [9:46] Enus Linden: well, it was suggested as a short term option. i don't think it was discussed so much as implemented
* [9:46] Infinity Linden: but Tess pointed it out to me
* [9:47] Locklainn Linden: right, that's what I though
* [9:47] Locklainn Linden: thought*
* [9:47] Enus Linden: i am not at all opposed to refactoring and updating docs as needed
* [9:47] Infinity Linden: well... i'm trying to get my tests completed so I can move on to other things
* [9:47] Locklainn Linden: so, that can be changed if need be
* [9:47] Infinity Linden: so i'm all about going with what's currently documented
* [9:47] Locklainn Linden: awesome
* [9:48] Infinity Linden: and getting to a point where I can run a test suite that hammers the system in a proscribed way
* [9:48] Infinity Linden: okay... with tht... lemme just say
* [9:48] Infinity Linden: i've spent the last day working on the OGP spec and trying to figure out buildout, python eggs, etc.
* [9:49] Infinity Linden: and doctest
* [9:49] Infinity Linden: i guess we'er using doctests and not pyunit or something?
* [9:49] Locklainn Linden: both really
* [9:49] Enus Linden: we are using both
* [9:49] Berry Steinhoff: hello everyone
* [9:49] Infinity Linden: cool
* [9:49] Infinity Linden: i'm more familiar with unittest
* [9:49] Infinity Linden: so
* [9:49] Enus Linden: the unittests are a combo of doctest and unittest (run via zope.testing.testrunner)
* [9:49] Locklainn Linden: so using pyunit for our unit testing
* [9:49] Infinity Linden: i'll probably not do a lot of doctests
* [9:49] Infinity Linden: btu
* [9:49] Infinity Linden: i like the idea
* [9:49] Tao Takashi: I think it depends on what you want to test what sort of test is best suited
* [9:49] Locklainn Linden: doctest to show how to use things, like documentation
* [9:50] Enus Linden: the interop tests are unittest style
* [9:50] Infinity Linden: well... there's a lot of work to get the doctests to spit out XML
* [9:50] Infinity Linden: carp
* [9:50] Infinity Linden: that reminds me
* [9:50] Infinity Linden: I still haven't dug up that reference to CUNIT's XML reporting format
* [9:50] Tao Takashi: do the unittests spit out XML?
* [9:50] Infinity Linden: they do now
* [9:50] Enus Linden: infinity's do :)
* [9:51] Infinity Linden: I'm using the CUNIT XML format for report generation
* [9:51] Infinity Linden: it's not.. uh.. beautiful
* [9:51] Tao Takashi: well, that's maybe more important for interop
* [9:51] Infinity Linden: but it is standard XMl and peeps have generated XSLT to make it pretty in a browser
* [9:51] Tao Takashi: so keep it unittests there then :)
* [9:52] Infinity Linden: yeah.. that's why i was a touch worried when i heard people start talking about doctests
* [9:52] Infinity Linden: btu as long as we're using doctests for things that doctest is good at
* [9:52] Infinity Linden: and unittest fo the things unittest is good at
* [9:52] Infinity Linden: i think it works well
* [9:52] Infinity Linden: but
* [9:52] Infinity Linden: oh
* [9:52] Infinity Linden: one last thing
* [9:52] Infinity Linden: there are definite changes to OGP coming down the pike
* [9:53] Infinity Linden: we're still hammering them out
* [9:53] Enus Linden: have these changes been discussed in zero's office hours and such?
* [9:53] Infinity Linden: and i mention it only to reiterate that what we have now is not the be-all end-all
* [9:53] Enus Linden: (i've been missing those lately)
* [9:53] Tao Takashi: would again like the hammering being more in public ;-)
* [9:53] Infinity Linden: yup
* [9:53] Infinity Linden: yeah
* [9:53] Saijanai Kuhn: you look a tad buggy today, Neus...
* [9:53] Infinity Linden: we're going ot hammer on them internally a bit
* [9:53] Infinity Linden: then publish them to be hammered on in the community
* [9:53] Enus Linden: sai, you looked like this when i first met you lol
* [9:54] Infinity Linden: okay. .i've taken up too much time already
* [9:54] Infinity Linden: next?
* [9:54] Locklainn Linden: guess I'll go
* [9:54] Locklainn Linden: so I finished up the message system
* [9:54] Locklainn Linden: got it tested to send and receive messages
* [9:54] Locklainn Linden: with a mockup udp client and server
* [9:55] Infinity Linden: w00t
* [9:55] Infinity Linden: checked in>
* [9:55] Infinity Linden: ?
* [9:55] Locklainn Linden: I started working on enus' teleport test
* [9:55] Locklainn Linden: to put in the udp communications needed
* [9:55] Locklainn Linden: yep, checked in
* [9:55] Infinity Linden: aw3sum
* [9:56] Enus Linden: pyogp.lib.base.message
* [9:56] Enus Linden: tao, how's pyogp for you lately? :)
* [9:57] Tao Takashi: well, I don't have any clue what's going on ;-)
* [9:57] Enus Linden: let's fix that shall we?
* [9:57] Locklainn Linden: yep, good idea
* [9:57] Tao Takashi: that would be good, mainly it's missing docs for the message system for me
* [9:58] Tao Takashi: and I still don't get where host and port are set and what each component actually does
* [9:58] Tao Takashi: hence my example loop I posted as an example of how I'd use it
* [9:58] Enus Linden: lock, might you be able to provide those shortly?
* [9:58] Locklainn Linden: short answer, host and port are given when you want to send a message
* [9:58] Locklainn Linden: I know there may be other designs
* [9:58] Locklainn Linden: which we should discuss if anyone disagrees with how its done
* [9:58] Locklainn Linden: but, as for the docs,
* [9:58] Tao Takashi: well, as I see the host is in the circuit stuff and the port in the message stuff
* [9:58] Locklainn Linden: I can write up the docs
* [9:58] Saijanai Kuhn: Tess lkeft a comment about the legacy login being taken out of OGP
* [9:59] Locklainn Linden: but for now the tests should be helpful
* [9:59] Infinity Linden: hmm...
* [9:59] Infinity Linden: legacy is there now
* [9:59] Infinity Linden: and probably for the time being
* [9:59] Locklainn Linden: ip and port combo make u a host
* [9:59] Saijanai Kuhn: it was in response to Tao's Example Loop message
* [9:59] Infinity Linden: in 18 months? it'll definitely be gone
* [9:59] Locklainn Linden: and IS stored in the circuit
* [9:59] Saijanai Kuhn: she said that she and Zero went through and eliminated it from the docs, but I couldn't find which docs she meant
* [10:00] Enus Linden: Tao, can we catch up later today?
* [10:00] Tao Takashi: and my starting point would be when I get host and port from place_avatar and I am wondering why I don't put host and port into the constructor together
* [10:00] Tao Takashi: sure
* [10:00] Enus Linden: lemme know a good time (or times) for you. and thanks
* [10:00] Locklainn Linden: yea, that's a design decision
* [10:01] Locklainn Linden: anyway, I'll write up the docs
* [10:01] Locklainn Linden: when I get a chance
* [10:01] Tao Takashi: tell LL to drop deadlines ;-)
* [10:01] Locklainn Linden: :)
* [10:01] Enus Linden: they are gone now tao
* [10:01] Tao Takashi: I am at least pretty blocked by not having docs
* [10:01] Infinity Linden: eek
* [10:01] Enus Linden: pyogp supports in some fashion or another testing an OGP enabled grid.
* [10:01] Locklainn Linden: I'm not sure why the tests don't help you...
* [10:02] Infinity Linden: i'm getting time constrained
* [10:02] Tao Takashi: because there is no text about what's happening
* [10:02] Tao Takashi: only code
* [10:02] Tao Takashi: and why something needs to be put where etc.
* [10:02] Infinity Linden: (it's my own damn fault of course)
* [10:02] Infinity Linden: but i gotta run
* [10:02] Infinity Linden: cheers
* [10:02] Infinity Linden: all
* [10:02] Tao Takashi: cheers Infinity!
* [10:02] Saijanai Kuhn: laters infinity6
* [10:02] Locklainn Linden: cya infinity
* [10:02] Enus Linden: inf, lemma know if i can help out at all
* [10:02] Bartholomew Kleiber: bye
* [10:02] Enus Linden: catch ya laters
* [10:02] Tao Takashi: and maybe because putting port and host in different locations is quite unusual and I am confused by this ;-)
* [10:03] Tao Takashi: and my problem is also understanding the difference between circuitmanager and message system I think
* [10:03] Locklainn Linden: you don't need to know about the circuit manager
* [10:03] Tao Takashi: I actually thought the event queue I put in the example would be the message system
* [10:04] Locklainn Linden: well, the event queue isn't a messaging system
* [10:04] Locklainn Linden: its an event queue :)
* [10:04] Saijanai Kuhn: yeah, its one way
* [10:04] Locklainn Linden: its just one way to get a message from the server
* [10:04] Locklainn Linden: in fact, its a cap
* [10:04] Saijanai Kuhn: its an alternate pipe for receiving UDP packets
* [10:04] Tao Takashi: to me it's an endpoint to the sim for instance
* [10:05] Saijanai Kuhn: though there are new messages that aren't documented in the UDP messages file
* [10:05] Tao Takashi: and you are creating the message inside the message system as instance variable, is this correct?
* [10:05] Locklainn Linden: sorta
* [10:06] Locklainn Linden: you create a message using the mesaging system
* [10:06] Tao Takashi: and not passing a message in when you want to send it
* [10:06] Locklainn Linden: which then delegates the message creating to a builder
* [10:06] Tao Takashi: so it's sort of a session for message creation?
* [10:06] Locklainn Linden: then you just send it
* [10:06] Locklainn Linden: yea
* [10:06] Locklainn Linden: when you do ms.send_message
* [10:06] Locklainn Linden: it will send the message you last created
* [10:06] Tao Takashi: I fear that's not really threadsafe
* [10:06] Saijanai Kuhn: all messages are sent via UPD at this point, except the login/TP OGP ones, rith?
* [10:07] Saijanai Kuhn: right?
* [10:07] Tao Takashi: event queue get on AD is also TCP
* [10:07] Locklainn Linden: no, the event queue messages are sent as well
* [10:07] Enus Linden: sai, some things have moved to tcp
* [10:07] Tao Takashi: but there is nothing happening yet
* [10:07] Enus Linden: i'm not sure what the *some* are though
* [10:07] Saijanai Kuhn: are there any EQ messages SENT?
* [10:08] Tao Takashi: so I would find it easier to constract a message and then pass it to some connection to send it over
* [10:08] Tao Takashi: or listen to that connection to receive a message
* [10:08] Saijanai Kuhn: EQG was only sending a request for next mesage I thought
* [10:08] Locklainn Linden: right Tao, but the way its done now is becasue the message system is designed to send http messages as well
* [10:08] Locklainn Linden: so when y ou attempt to create a message
* [10:08] Locklainn Linden: it determines what sort of message should be built
* [10:09] Tao Takashi: well, this would be a separate connection then in my case and you can do connection.send(Message) as well
* [10:09] Locklainn Linden: template, or llsd
* [10:09] Tao Takashi: they have different hosts and ports anyway and need to bind to different sockets
* [10:09] Locklainn Linden: this way is just about delegating
* [10:09] Locklainn Linden: everything can go through the message system
* [10:09] Locklainn Linden: of course there are other ways of doing it
* [10:09] Locklainn Linden: this is just the way I did it
* [10:10] Locklainn Linden: you don't eeven need to know about the connections
* [10:10] Locklainn Linden: or what type of messages you are building
* [10:10] Locklainn Linden: or reading
* [10:10] Locklainn Linden: you nust create it and send it
* [10:10] Locklainn Linden: message system takes care of all of that
* [10:10] Tao Takashi: ok, but in the end I probably don't want to create raw messages but more abstract ones
* [10:10] Locklainn Linden: message system knows what format the message should be in, who it should be sent to,
* [10:10] Locklainn Linden: becasue of the message
* [10:11] Locklainn Linden: what is an abstract message?
* [10:11] Tao Takashi: AgentUpdateMessage(head_rotation=(3.0,200.0,172.0)
* [10:11] Tao Takashi: )
* [10:11] Locklainn Linden: why is that abstract?
* [10:11] Tao Takashi: which will internally do the formatting for me
* [10:11] Tao Takashi: because it abstracts from the message template
* [10:11] Locklainn Linden: well, you can't do things that way
* [10:11] Tao Takashi: it has domain knowledge about the agent update mechanism and knows default values and such
* [10:11] Locklainn Linden: czu of blocks
* [10:12] Tao Takashi: it can create blocks if needed maybe
* [10:12] Tao Takashi: as it should internally know about the structure
* [10:12] Locklainn Linden: yea
* [10:12] Locklainn Linden: I dunno
* [10:12] Locklainn Linden: i guess if you want to write your own udp messaging system, then go ahead :)
* [10:12] Tao Takashi: and if you have such specialized messages you could derive from a superclass which does stuff which every message needs to do
* [10:12] Locklainn Linden: cuz that is changing everything
* [10:13] Tao Takashi: really? wouldn't this only affect the message system class? and not the encoding stuff
* [10:13] Locklainn Linden: no, cuz you are building messages differently
* [10:14] Locklainn Linden: and therefore reading them differently
* [10:14] Locklainn Linden: message system is just a delgation object
* [10:14] Saijanai Kuhn: Seems to me that you've created the structure for doing what Tao would like... The details of building it from that structure have to be worked out
* [10:14] Locklainn Linden: almost, except he has a whole different concept of how messages should be created
* [10:15] Tao Takashi: Hm, I will keep reading the code :)
* [10:15] Saijanai Kuhn: I'd avoid having a name for each message builder anyway. Just use a generic one with the name of the mssage as the first parameter
* [10:16] Locklainn Linden: name for each message BUILDER?
* [10:16] Locklainn Linden: what do you mean?
* [10:16] Saijanai Kuhn: [10:11
* [10:16] Locklainn Linden: thats a message, not a builder though
* [10:16] Locklainn Linden: is that what you mean?
* [10:16] Locklainn Linden: hmm
* [10:16] Locklainn Linden: yes, u are right
* [10:16] Locklainn Linden: thats what I mean by tao's concept changes everything
* [10:16] Saijanai Kuhn: right but it implicitly builds the message during the call
* [10:17] Locklainn Linden: because that is the message AND the builder
* [10:17] Locklainn Linden: right
* [10:17] Tao Takashi: can't it use a builder?
* [10:17] Tao Takashi: I really need to read the code
* [10:17] Locklainn Linden: doesn't seem to make sense to have a message use a builder to build itself :)
* [10:17] Saijanai Kuhn: well there are 500+ message templates. I'd hate to have to name 500 functions
* [10:17] Tao Takashi: well, it's creating it's payload ;-)
* [10:18] Locklainn Linden: right, that too sai
* [10:18] Tao Takashi: Sai: but then you want to manually write each packet manually?
* [10:18] Tao Takashi: I would rather abstract this out and be testable inside the message types
* [10:18] Locklainn Linden: what do you mean tao?
* [10:18] Saijanai Kuhn: msg.build{AgentUpdateMessage, head_rotation=(3.0,200.0,172.0))
* [10:18] Saijanai Kuhn: msg.send()
* [10:18] Tao Takashi: stuff like
* [10:18] Locklainn Linden: right
* [10:18] Tao Takashi: self.message_system.next_block('Packets') self.message_system.add_data('ID', 0x00000003, MsgType.MVT_U32)
* [10:18] Locklainn Linden: well, you have to do the block stuff that way
* [10:19] Locklainn Linden: cuz you can have multple blocks with the same name
* [10:19] Locklainn Linden: and of course the ms i wrote can be written a bit different to have a different api
* [10:19] Tao Takashi: sure but I might find a slightly different interface for the abstract message which then converts it to the blocks
* [10:19] Saijanai Kuhn: you could conceal that within the msg.build(name,...)
* [10:20] Locklainn Linden: yea, you could combnie new_message with next_block and add_data
* [10:20] Locklainn Linden: but then you would have a REAAAALY long call
* [10:20] Tao Takashi: I did an example of blocks in the loop
* [10:20] Tao Takashi: basically where you have a variable block with uuids
* [10:20] Saijanai Kuhn: put it all in a dictionary, with each block defined in the dictionary
* [10:20] Tao Takashi: and it's NameUUIDRequest(uuids=[uuid1,uuid2, ...])
* [10:20] Tao Takashi: which internall will create those blocks
* [10:21] Locklainn Linden: thats in ur email yes?
* [10:21] Tao Takashi: yes, something like this
* [10:21] Tao Takashi: wrote it down from memory
* [10:21] Tao Takashi: not that what I mailed works anyway ;-)
* [10:21] Locklainn Linden: so I'm looking at IAgentUpdatemessage
* [10:21] Tao Takashi: but in the end I would like to keep the user of that lib away from knowing the packet structure
* [10:21] Locklainn Linden: well
* [10:21] Locklainn Linden: you AHVE to know the structure
* [10:21] Saijanai Kuhn: Dict= msg.buildblock(name, data)
* [10:22] Locklainn Linden: how do you know what to send in the packet without knowing its structure?
* [10:22] Tao Takashi: the lib knows the structure and gives the user an interface which is more pythonic to fill in that structure
* [10:22] Locklainn Linden: so, are you just saying no next_block stuff?
* [10:22] Tao Takashi: and those message translate it to the message structure
* [10:22] Tao Takashi: yes
* [10:22] Tao Takashi: there might be a semantic of when you need blocks
* [10:22] Tao Takashi: this can probably expressed differently
* [10:22] Tao Takashi: like in uuids=[a,b,c]
* [10:23] Saijanai Kuhn: msg.appendblock (name, dict, data) msg.build(name,dict)
* [10:23] Locklainn Linden: thats what is done sai
* [10:23] Locklainn Linden: ok, so looking at ur agentupdate in ur email
* [10:23] Locklainn Linden: you do
* [10:23] Locklainn Linden: message.camera_center
* [10:23] Locklainn Linden: message.body_rotation
* [10:23] Locklainn Linden: etc
* [10:23] Locklainn Linden: so you DO know the packet structure
* [10:23] Tao Takashi: and if you have abstract messages the underlying structure could even change slightly without the need for the user to change his application
* [10:23] Locklainn Linden: you just don't know which block those belong to
* [10:23] Locklainn Linden: yes?
* [10:24] Tao Takashi: I know the properties
* [10:24] Tao Takashi: not if it's in some block etc.
* [10:24] Tao Takashi: well, the user only needs to know these
* [10:24] Tao Takashi: the lib knows the details of course
* [10:24] Tao Takashi: and many can have default values
* [10:24] Saijanai Kuhn: well, you need to have some idea of hte block, or the underlying builder does
* [10:24] Locklainn Linden: right, but then what heppsn when you have 2 block sin the message that both have a body_rotation?
* [10:24] Tao Takashi: so this example in the email just lists all but you might omit some
* [10:25] Tao Takashi: then you can use properties like body_rotation_a and body_rotation_b
* [10:25] Tao Takashi: there might be some reason for having two or more and this can probably be expressed somehow
* [10:25] Tao Takashi: but I need examples ;-)
* [10:25] Saijanai Kuhn: I'm tending to side more with Locklainn on this. With multile blocks, you need to add them in separately
* [10:25] Tao Takashi: unfortunately not too many messages are documented
* [10:25] Locklainn Linden: if you look at message_template.msg
* [10:25] Locklainn Linden: every block that is of type MULTIPLE or VARIABLE
* [10:25] Locklainn Linden: will have many blocks with the same variables
* [10:26] Tao Takashi: just looking at some message
* [10:26] Locklainn Linden: ok, which, I can look with you
* [10:26] Tao Takashi: so I would say these are mostly lists
* [10:26] Tao Takashi: SimulatorPresentAtLocation
* [10:26] Tao Takashi: 11
* [10:26] Saijanai Kuhn: for simple messages you could do it with acombined msg.send(name, data) but for more complicated messages you'll need itnermediate build steps
* [10:27] Tao Takashi: 
* [10:27] Locklainn Linden: well, every block is a new list of attributes
* [10:27] Tao Takashi: yep, one could even use some classes for modelling this
* [10:28] Tao Takashi: or simply some dicts
* [10:28] Locklainn Linden: but then all you are doing is just replicating the block construction
* [10:28] Locklainn Linden: in a differetn place :)
* [10:28] Tao Takashi: yes
* [10:28] Saijanai Kuhn: right, at best you could create a dict of dicts but you'd need to construct those dictionaries before hand or send in a really complicated structure, like Lock says
* [10:28] Locklainn Linden: its the same thing
* [10:28] Tao Takashi: and providing defaults
* [10:28] Tao Takashi: and make it more readable
* [10:28] Locklainn Linden: not more redable really
* [10:28] Locklainn Linden: hhow is it more readable than doing
* [10:28] Locklainn Linden: new_message
* [10:28] Locklainn Linden: next_block
* [10:28] Locklainn Linden: add_data
* [10:28] Locklainn Linden: next_block
* [10:28] Locklainn Linden: add_data
* [10:28] Locklainn Linden: :)
* [10:28] Tao Takashi: well, I can say message.sim_pub_host_port = 1080
* [10:28] Locklainn Linden: very readable
* [10:29] Saijanai Kuhn: i don't see it aqs more readable either. msg.buildblock(name, data) is reasonably readable
* [10:29] Locklainn Linden: yea, its either a string or an instance variable
* [10:29] Locklainn Linden: still get same info
* [10:29] Locklainn Linden: juts how you want to think of a packet being constructed
* [10:29] Tao Takashi: what happens if you forget some add_data?
* [10:29] Locklainn Linden: you can't send the message
* [10:29] Locklainn Linden: will get an error
* [10:29] Tao Takashi: but that means you also have to add them all
* [10:30] Locklainn Linden: yea
* [10:30] Tao Takashi: in the abstract message case you could provide defaults
* [10:30] Locklainn Linden: so you want a message
* [10:30] Locklainn Linden: taht can have ANY number of variables
* [10:30] Locklainn Linden: yes?
* [10:30] Locklainn Linden: that's what you mean by abstract message
* [10:30] Tao Takashi: and you could also store a message locally like aumsg = AgentUpdateMessage(...), then send it, then modify it and send it again
* [10:30] Tao Takashi: because you moved your head or so
* [10:30] Saijanai Kuhn: you can semi automate the building based on teh template, but you still need to be able to add the blocks because no way you want to construct some of those templates by hand by passing in all parameters
* [10:31] Locklainn Linden: I don't think there are any use cases for this stuff though
* [10:31] Locklainn Linden: we know all the messages we are going to send
* [10:31] Locklainn Linden: how they are constructed
* [10:31] Tao Takashi: well, the head rotation change would be a use case I can think of
* [10:31] Locklainn Linden: yes,
* [10:31] Locklainn Linden: but the send_message allows you to pass in a message
* [10:31] Locklainn Linden: that it will use
* [10:31] Saijanai Kuhn: well, with python's abilities to handle arbitrary numbers of defaulted parameters, it would be doable
* [10:31] Locklainn Linden: so if you store the message somewhere, you can just do that instead
* [10:31] Tao Takashi: so you only do aumg.head_rotation=new_rotation; msgsys.send(aumsg)
* [10:32] Tao Takashi: ok, then it might be similar ;-)
* [10:32] Saijanai Kuhn: must run will post this on the wiki when I get back
* [10:32] Tao Takashi: but then why having 2 ways of constructing a message? ;-)
* [10:32] Locklainn Linden: thanks sai
* [10:32] Tao Takashi: thanks, sai! you rock! :)
* [10:32] Locklainn Linden: its not constructing a message at that point
* [10:32] Saijanai Kuhn: doing a afk
* [10:33] Saijanai Kuhn: but not saying the dreaed worrd cause then I log out
* [10:33] Locklainn Linden: haha
* [10:33] Locklainn Linden: that send_message function allows you to build your own message elsewhere
* [10:33] Locklainn Linden: might have to look at that again to make sure
* [10:33] Locklainn Linden: cuz I didn't have any use cases for it
* [10:34] Locklainn Linden: but
* [10:34] Tao Takashi: well, beside that all I can say is that I am confused by this way of doing it but that is of course very subjective ;-)
* [10:34] Locklainn Linden: all you want to do is somehow convert my strings to instance varaibles
* [10:34] Tao Takashi: and as I said I see problems with threads
* [10:34] Locklainn Linden: well
* [10:34] Tao Takashi: but this will always be tricky I guess
* [10:35] Locklainn Linden: using the message system should be locked
* [10:35] Locklainn Linden: how would you send a mesage using a single message system otherwise?
* [10:35] Locklainn Linden: you may need 2 message systems
* [10:35] Locklainn Linden: or 1 per thread
* [10:35] Tao Takashi: yep
* [10:35] Tao Takashi: it would model those 2 connections the client has
* [10:35] Locklainn Linden: the point of the messenger is to abstract away from knowing the connections
* [10:36] Locklainn Linden: the messenger sets all that up
* [10:36] Tao Takashi: but I need to initialize them anyway when I get host and port where to send stuff to
* [10:36] Locklainn Linden: you need to know ip and port, yea
* [10:36] Tao Takashi: and how do you actually handle if AD and RD have different ports?
* [10:36] Tao Takashi: because as I see it the port is now sorta global
* [10:36] Locklainn Linden: luckily,
* [10:36] Locklainn Linden: message system isn't bound to a single port
* [10:36] Locklainn Linden: like you wanted
* [10:37] Locklainn Linden: send_message has a host
* [10:37] Locklainn Linden: which is target ip and port
* [10:37] Tao Takashi: ah, ic
* [10:37] Locklainn Linden: the port you initialize the message system with is the receving port
* [10:37] Tao Takashi: but don't you need an ip address for this aswell?
* [10:37] Locklainn Linden: yea
* [10:37] Locklainn Linden: but you get that easily
* [10:37] Locklainn Linden: by calling socket.gethostname
* [10:37] Locklainn Linden: or something like that
* [10:37] Locklainn Linden: you don't need to know it in the code
* [10:38] Locklainn Linden: it is not configurable aka
* [10:38] Locklainn Linden: for instance, you can't receive a message on a different ip other than ur own machine
* [10:38] Tao Takashi: but I might want to define whether it listens on 127.0.0.1 or some other IP I have configured
* [10:39] Locklainn Linden: well, I'm not sure about that
* [10:39] Tao Takashi: and what happens if you need to listen on different ips for different connections?
* [10:39] Locklainn Linden: messenger is assumeing you want to set up the messenger on ur own machine
* [10:39] Locklainn Linden: wait
* [10:39] Locklainn Linden: you don't listen on different ips
* [10:39] Locklainn Linden: yo ulsiten on different ports
* [10:39] Tao Takashi: or ports at least
* [10:39] Locklainn Linden: yes?
* [10:39] Tao Takashi: but it might be different ips as well
* [10:39] Locklainn Linden: not really
* [10:39] Locklainn Linden: but about listening on differetn ports
* [10:40] Locklainn Linden: you need a differetn messenger
* [10:40] Locklainn Linden: a hence a good use of threading :)
* [10:40] Tao Takashi: you said, TCP is also supported
* [10:41] Tao Takashi: iirc ;-)
* [10:41] Locklainn Linden: not yet
* [10:41] Locklainn Linden: but is supposed to be
* [10:41] Tao Takashi: where actually is TCP used in the current protocol?
* [10:41] Locklainn Linden: event queue
* [10:41] Locklainn Linden: so, http
* [10:41] Locklainn Linden: more than tcp
* [10:41] Tao Takashi: is this the HTTP connection then?
* [10:41] Tao Takashi: ok, but we already have a client for that anyway, don't we?
* [10:41] Tao Takashi: I would call the cap and get back some message
* [10:41] Tao Takashi: and need to give it something to decode it
* [10:41] Movies1963 Beck: can I ask a qustion
* [10:42] Tao Takashi: while I have no idea how such a message would look like to be honest ;-)
* [10:42] Tao Takashi: sure, Movies
* [10:42] Locklainn Linden: well, the point of having the messenger be usable for http as well
* [10:42] Locklainn Linden: allows you to create and send llsd mesages
* [10:42] Movies1963 Beck: when will we be able to put webpages on prims,please answer in English
* [10:42] Locklainn Linden: and the messenger knows WHERE they should be going
* [10:42] Tao Takashi: Movies: you better ask a Linden ;-)
* [10:42] Tao Takashi: how does it know? :)
* [10:42] Locklainn Linden: Movies: you better ask a different linden :)
* [10:43] Bartholomew Kleiber: from what I understand a messading system usually only needs one instance. To handle the ip/port issue, the socket should be part of the message, probably.
* [10:43] Tao Takashi: I guess it would be good to know which Linden ;-)
* [10:43] Locklainn Linden: right
* [10:43] Tao Takashi: I somehow dislike putting in the socket all the time
* [10:43] Tao Takashi: it's something that will never change
* [10:43] Movies1963 Beck: who's the webpage Linden?
* [10:43] Tao Takashi: so I would instantiate a connection to some component
* [10:43] Bartholomew Kleiber: the way you put it , it can change
* [10:43] Locklainn Linden: right
* [10:43] Bartholomew Kleiber: or at least, can be several
* [10:44] Locklainn Linden: so its either you create 2 messengers
* [10:44] Locklainn Linden: or you pass in the socket everytime
* [10:44] Tao Takashi: and pass in things into methods which are variable, not those which are fixed
* [10:44] Tao Takashi: these can be more easily and more conveniently stored in instance data IMHO
* [10:44] Locklainn Linden: im not sure what you mean
* [10:44] Tao Takashi: that's how network libs usually work
* [10:44] Bartholomew Kleiber: I suspect that when you create two message queues you'll someday want to peek into the other one, which could be hadled better in one.
* [10:45] Bartholomew Kleiber: handled*
* [10:45] Locklainn Linden: well,
* [10:45] Tao Takashi: well, it's called queues but I doubt that there will be a list of queued messages really
* [10:45] Locklainn Linden: I'll have to write the docs
* [10:45] Locklainn Linden: and you can rewrite ur own doc explaining how you would do the same thing
* [10:45] Locklainn Linden: and we can look at both
* [10:46] Tao Takashi: yes, will try
* [10:46] Tao Takashi: I will also read code :)
* [10:46] Locklainn Linden: ok
* [10:46] Locklainn Linden: well, gotta do some more testing
* [10:47] Tao Takashi: and btw, although I seem very critical here you've done a great job on the message system! :)
* [10:47] Locklainn Linden: but hopefully the docs will be up in a couple hours
* [10:47] Tao Takashi: cool!
* [10:47] Locklainn Linden: awesome
* [10:47] Locklainn Linden: ill be on irc as well, so we can chat there if you'd like
* [10:47] Locklainn Linden: just can't run sl and do work
* [10:47] Locklainn Linden: :)
* [10:47] Tao Takashi: we'll see how much time I have now
* [10:47] Tao Takashi: well, me neither ;-)
* [10:47] Locklainn Linden: yea
* [10:47] Bartholomew Kleiber: ok, see you all later
* [10:48] Locklainn Linden: haha
* [10:48] Locklainn Linden: thansk everyone
* [10:48] Tao Takashi: yes, cya all later! :)
* [10:48] Locklainn Linden: cya
* [10:48] Tao Takashi: thanks, Locklainn!
* [10:48] Berry Steinhoff: bye all. lots to think about. ty.
* [10:48] Locklainn Linden: np, thank you too
* [10:48] Tao Takashi: cya then
Category: Grid Interoperability Chat Logs
Category: AW Groupies Transcripts
Category: Pyogp Transcripts