Navigation

← Previous Changeset
Next Changeset →

Changeset 463

Timestamp:

02/28/03 00:10:31 (6 years ago)

Author:

sholloway

Message:

*** empty log message ***

Files:

trunk/RBFoundation/RBFoundation/XMLClassBuilder.py (modified) (2 diffs)
trunk/RBMessaging/RBMessaging/Client/Handlers/Authentication.py (modified) (5 diffs)
trunk/RBMessaging/RBMessaging/Client/Handlers/Error.py (modified) (3 diffs)
trunk/RBMessaging/RBMessaging/Client/Handlers/Message.py (modified) (5 diffs)
trunk/RBMessaging/RBMessaging/Host/Handlers/Authentication.py (modified) (4 diffs)
trunk/RBMessaging/RBMessaging/Host/Handlers/Error.py (modified) (3 diffs)
trunk/RBMessaging/RBMessaging/Host/Handlers/Message.py (modified) (5 diffs)
trunk/RBMessaging/RBMessaging/Model.py (modified) (3 diffs)
trunk/RBMessaging/RBMessaging/Packet/__init__.py (modified) (1 diff)
trunk/RBMessaging/demo/simple/host.py (modified) (1 diff)
trunk/RBMessaging/demo/simple/recv.py (modified) (1 diff)
trunk/RBMessaging/demo/simple/send.py (modified) (1 diff)
trunk/RBTelepathy/RBTelepathy/Connection.py (modified) (4 diffs)
trunk/RBTelepathy/RBTelepathy/Handlers/__init__.py (modified) (1 diff)
trunk/RBTelepathy/RBTelepathy/Packet/Builder.py (modified) (3 diffs)
trunk/RBTelepathy/RBTelepathy/Packet/__init__.py (modified) (1 diff)
trunk/RBTelepathy/demo/simple/client/AuthenticationHandler.py (modified) (2 diffs)
trunk/RBTelepathy/demo/simple/client/ErrorHandler.py (modified) (1 diff)
trunk/RBTelepathy/demo/simple/client/MessageHandler.py (modified) (1 diff)
trunk/RBTelepathy/demo/simple/host/AuthenticationHandler.py (modified) (2 diffs)
trunk/RBTelepathy/demo/simple/host/ErrorHandler.py (modified) (1 diff)
trunk/RBTelepathy/demo/simple/host/MessageHandler.py (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/RBFoundation/RBFoundation/XMLClassBuilder.py

r445	r463
24	24	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25	25
	26	from __future__ import generators
26	27	import XMLBuilder
27	28	import keyword
…	…
187	188
188	189	def copy(self):
189		return ~~ElementFactorySet~~(dict.copy(self))
	190	return self.__class__(dict.copy(self))
190	191
191	192	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
192	193	#~ Protected Methods
193	194	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	195
	196	def _GetElementFactoryIndices(self, node):
	197	idx = node
	198	while idx:
	199	yield idx
	200	idx = idx[:-1]
	201	yield None
194	202
195	203	def _GetElementFactory(self, owner, parent, node, attributes, namespacemap):
196	204	try:
197		idx = node
198		while idx:
199		FactoryFactory = self.get(idx, None)
200		if FactoryFactory:
	205	for idx in self._GetElementFactoryIndices(node):
	206	FactoryFactory = self.get(idx)
	207	if FactoryFactory is not None:
201	208	result = FactoryFactory(owner, parent, node, attributes, namespacemap)
202	209	if result:
203	210	return result
204		~~idx = idx[:-1]~~
205
206		~~# Resort to the default~~
207		~~FactoryFactory = self.get(None, None)~~
208		~~if FactoryFactory:~~
209		~~result = FactoryFactory(owner, parent, node, attributes, namespacemap)~~
210		~~if result:~~
211		~~return result~~
212
213	211	except ElementFactory.InheritFromNextFactory, (args, kw):
214	212	if self.NextFactorySet:

trunk/RBMessaging/RBMessaging/Client/Handlers/Authentication.py

r459	r463
25	25
26	26	from RBTelepathy.Handlers import *
27		~~from RBMessaging.Packet import RBNamespace~~
28	27
29	28	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
47	46	class method(Elements.PacketElement, XMLClassBuilderObjectMixin):
48	47	__slots__ = []
49		NamespaceSynonyms = {None: RBNamespace}
50		DefaultNamespace = NamespaceSynonyms[None]
51		ElementFactories = ElementFactorySet({
52		(RBNamespace, 'response'): Elements.Factory(Elements.PacketElement),
53		(RBNamespace, 'challenge'): Elements.Factory(Elements.PacketElement),
	48	ElementFactories = PacketFactorySet({
	49	'response': Elements.Factory(Elements.PacketElement),
	50	'challenge': Elements.Factory(Elements.PacketElement),
54	51	})
55	52
…	…
92	89	class authentication(Elements.RootElementBase, XMLClassBuilderObjectMixin):
93	90	__slots__ = []
94		NamespaceSynonyms = {None: RBNamespace}
95		DefaultNamespace = NamespaceSynonyms[None]
96		ElementFactories = ElementFactorySet({
97		(RBNamespace, 'as'): Elements.Factory(Elements.URIAddressElement),
98		(RBNamespace, 'method'): Elements.Factory(method),
	91	ElementFactories = PacketFactorySet({
	92	'as': Elements.Factory(Elements.URIAddressElement),
	93	'method': Elements.Factory(method),
99	94	})
100	95
…	…
106	101	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
107	102
108		ElementFactories = {~~(RBNamespace, 'authentication')~~: Elements.RootFactory(authentication)}
	103	ElementFactories = {'authentication': Elements.RootFactory(authentication)}
109	104	StreamPacketHandlers = ElementFactories.keys()
110	105
…	…
177	172
178	173	def _reply_response(self, packet, args, *kw):
179		packet = authentication(~~namespace=RBNamespace~~)
	174	packet = authentication()
180	175	packet.attrs['type'] = 'response'
181	176	packet += 'as',

trunk/RBMessaging/RBMessaging/Client/Handlers/Error.py

r459	r463
25	25
26	26	from RBTelepathy.Handlers import *
27		~~from RBMessaging.Packet import RBNamespace~~
28	27
29	28	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
33	32	class error(Elements.RootElementBase, XMLClassBuilderObjectMixin):
34	33	__slots__ = []
35		NamespaceSynonyms = {None: RBNamespace}
36		DefaultNamespace = NamespaceSynonyms[None]
37		ElementFactories = ElementFactorySet({
38		(RBNamespace, ): Elements.Factory(Elements.PacketElement),
	34	ElementFactories = PacketFactorySet({
	35	None: Elements.Factory(Elements.PacketElement),
39	36	})
40	37
…	…
46	43	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
47	44
48		ElementFactories = {~~(RBNamespace, 'error')~~: Elements.RootFactory(error)}
	45	ElementFactories = {'error': Elements.RootFactory(error)}
49	46	StreamPacketHandlers = ElementFactories.keys()
50	47

trunk/RBMessaging/RBMessaging/Client/Handlers/Message.py

r461	r463
25	25
26	26	from RBTelepathy.Handlers import *
27		~~from RBMessaging.Packet import RBNamespace~~
28	27	import copy
29	28
…	…
38	37
39	38	__slots__ = []
40		NamespaceSynonyms = {None: RBNamespace}
41		DefaultNamespace = NamespaceSynonyms[None]
42		ElementFactories = ElementFactorySet({
43		(RBNamespace, 'to'): Elements.Factory(Elements.URIAddressElement),
44		(RBNamespace, 'from'): Elements.Factory(Elements.URIAddressElement),
45		(RBNamespace, 'stream'): StreamElements.StreamFormatFactory(),
46		(RBNamespace, ): Elements.Factory(Elements.PacketElement),
	39	ElementFactories = PacketFactorySet({
	40	'to': Elements.Factory(Elements.URIAddressElement),
	41	'from': Elements.Factory(Elements.URIAddressElement),
	42	'stream': StreamElements.StreamFormatFactory(),
47	43	None: Elements.Factory(Elements.PacketElement),
48	44	})
49		~~default_namespaces = Elements.StreamRootElement.default_namespaces.copy()~~
50		~~default_namespaces.setxmlns('', RBNamespace)~~
51	45
52	46	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
55	49
56	50	def GetAddresses(self, nodename='to'):
57		existing = self.iternodes(nodename~~, RBNamespace~~)
	51	existing = self.iternodes(nodename)
58	52	result = [each.addr for each in existing]
59	53	return result
…	…
69	63	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
70	64
71		ElementFactories = {~~(RBNamespace, 'message')~~: Elements.RootFactory(message)}
	65	ElementFactories = {'message': Elements.RootFactory(message)}
72	66	StreamPacketHandlers = ElementFactories.keys()
73	67
…	…
80	74	def __init__(self, connection):
81	75	self.connection = connection
82		~~router = connection.model().Routers.get((RBNamespace, 'message'), None)~~
83	76
84	77	def OnRoutedPacket(self, packet, addresses):

trunk/RBMessaging/RBMessaging/Host/Handlers/Authentication.py

r459	r463
25	25
26	26	from RBTelepathy.Handlers import *
27		~~from RBMessaging.Packet import RBNamespace~~
28	27
29	28	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
33	32	class AuthBaseMethod(Elements.PacketElement, XMLClassBuilderObjectMixin):
34	33	__slots__ = []
35		NamespaceSynonyms = {None: RBNamespace}
36		DefaultNamespace = NamespaceSynonyms[None]
37		ElementFactories = ElementFactorySet({
38		(RBNamespace, 'response'): Elements.Factory(Elements.PacketElement),
39		(RBNamespace, 'challenge'): Elements.Factory(Elements.PacketElement),
	34	ElementFactories = PacketFactorySet({
	35	'response': Elements.Factory(Elements.PacketElement),
	36	'challenge': Elements.Factory(Elements.PacketElement),
40	37	})
41	38
…	…
118	115	class authentication(Elements.RootElementBase, XMLClassBuilderObjectMixin):
119	116	__slots__ = []
120		NamespaceSynonyms = {None: RBNamespace}
121		DefaultNamespace = NamespaceSynonyms[None]
122		ElementFactories = ElementFactorySet({
123		(RBNamespace, 'as'): Elements.Factory(Elements.URIAddressElement),
124		(RBNamespace, 'method'): Elements.Factory(DefaultAuthMethod),
	117	ElementFactories = PacketFactorySet({
	118	'as': Elements.Factory(Elements.URIAddressElement),
	119	'method': Elements.Factory(DefaultAuthMethod),
125	120	})
126	121
…	…
132	127	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
133	128
134		ElementFactories = {~~(RBNamespace, 'authentication')~~: Elements.RootFactory(authentication)}
	129	ElementFactories = {'authentication': Elements.RootFactory(authentication)}
135	130	StreamPacketHandlers = ElementFactories.keys()
136	131

trunk/RBMessaging/RBMessaging/Host/Handlers/Error.py

r459	r463
25	25
26	26	from RBTelepathy.Handlers import *
27		~~from RBMessaging.Packet import RBNamespace~~
28	27
29	28	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
33	32	class error(Elements.RootElementBase, XMLClassBuilderObjectMixin):
34	33	__slots__ = []
35		NamespaceSynonyms = {None: RBNamespace}
36		DefaultNamespace = NamespaceSynonyms[None]
37		ElementFactories = ElementFactorySet({
38		(RBNamespace, ): Elements.Factory(Elements.PacketElement),
	34	ElementFactories = PacketFactorySet({
	35	None: Elements.Factory(Elements.PacketElement),
39	36	})
40	37
…	…
46	43	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
47	44
48		ElementFactories = {~~(RBNamespace, 'error')~~: Elements.RootFactory(error)}
	45	ElementFactories = {'error': Elements.RootFactory(error)}
49	46	StreamPacketHandlers = ElementFactories.keys()
50	47

trunk/RBMessaging/RBMessaging/Host/Handlers/Message.py

r459	r463
25	25
26	26	from RBTelepathy.Handlers import *
27		~~from RBMessaging.Packet import RBNamespace~~
28	27	import copy
29	28
…	…
38	37
39	38	__slots__ = []
40		NamespaceSynonyms = {None: RBNamespace}
41		DefaultNamespace = NamespaceSynonyms[None]
42		ElementFactories = ElementFactorySet({
43		(RBNamespace, 'to'): Elements.Factory(Elements.URIAddressElement),
44		(RBNamespace, 'from'): Elements.Factory(Elements.URIAddressElement),
45		(RBNamespace, 'stream'): StreamElements.StreamFormatFactory(),
46		(RBNamespace, ): Elements.Factory(Elements.PacketElement),
	39	ElementFactories = PacketFactorySet({
	40	'to': Elements.Factory(Elements.URIAddressElement),
	41	'from': Elements.Factory(Elements.URIAddressElement),
	42	'stream': StreamElements.StreamFormatFactory(),
47	43	None: Elements.Factory(Elements.PacketElement),
48	44	})
49		~~default_namespaces = Elements.StreamRootElement.default_namespaces .copy()~~
50		~~default_namespaces.setxmlns('', RBNamespace)~~
51	45
52	46	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
69	63	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
70	64
71		ElementFactories = {~~(RBNamespace, 'message')~~: Elements.RootFactory(message)}
	65	ElementFactories = {'message': Elements.RootFactory(message)}
72	66	StreamPacketHandlers = ElementFactories.keys()
73	67
…	…
80	74	def __init__(self, connection):
81	75	self.connection = connection
82		self.router = connection.model().GetRouter(~~(RBNamespace, 'message')~~)
	76	self.router = connection.model().GetRouter('message')
83	77	if self.router:
84	78	key = connection.loginaddr.authority
…	…
102	96	self.log.info('Sending "%s" packet to Router', packet.node)
103	97	if not self.router:
104		self.router = connection.model().GetRouter(~~(RBNamespace, 'message')~~)
	98	self.router = connection.model().GetRouter('message')
105	99	if not self.router:
106	100	raise ErrorTypes.RoutingError, 'No router available'

trunk/RBMessaging/RBMessaging/Model.py

r459	r463
32	32	from RBTelepathy import SocketConnections
33	33
34		~~from RBMessaging.Packet import RBNamespace~~
35
36	34	from Router import SimpleRouter
37	35	import Client.Connection
…	…
50	48	self.Connections = {}
51	49	self.Routers = {}
52		self.Routers[~~(RBNamespace, 'message')~~] = SimpleRouter.AuthorityDictRouter()
	50	self.Routers['message'] = SimpleRouter.AuthorityDictRouter()
53	51
54	52	def GetRouter(self, key):
…	…
95	93	try:
96	94	model = Model()
97		model.Serve(~~None~~)
98		send = model.Connect(~~None~~).Login('send')
	95	model.Serve()
	96	send = model.Connect().Login('send')
99	97	while not getattr(send, 'loginaddr', None):
100	98	model.Process(0.1)
101		recv = model.Connect(~~None~~).Login('recv')
	99	recv = model.Connect().Login('recv')
102	100	while not getattr(recv, 'loginaddr', None):
103	101	model.Process(0.1)

trunk/RBMessaging/RBMessaging/Packet/init.py

r459	r463
31	31
32	32	#RBNamespace = 'http://namespaces.runeblade.com/RBMessaging'
33		RBNamespace = 'RBM'
	33	RBNamespace = 'RBMessaging'
34	34
35	35	RBNamespaceSynonyms = {

trunk/RBMessaging/demo/simple/host.py

r462	r463
38	38	try:
39	39	model = Model()
40		model.Serve(~~None~~)
	40	model.Serve()
41	41	while 1: model.Process(0.1)
42	42	except KeyboardInterrupt:

trunk/RBMessaging/demo/simple/recv.py

r462	r463
38	38	try:
39	39	model = Model()
40		recv = model.Connect(~~None~~).Login('recv')
	40	recv = model.Connect().Login('recv')
41	41	while 1:
42	42	model.Process(0.1)

trunk/RBMessaging/demo/simple/send.py

r462	r463
38	38	try:
39	39	model = Model()
40		send = model.Connect(~~None~~).Login('send')
	40	send = model.Connect().Login('send')
41	41	while not getattr(send, 'loginaddr', None):
42	42	model.Process(0.1)

trunk/RBTelepathy/RBTelepathy/Connection.py

r459	r463
41	41	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
42	42
	43	from __future__ import generators
43	44	import logging
44	45	import weakref
…	…
117	118
118	119	# Lookup our packet handler
119		packethandler = self.RoutedPacketHandlers.get((packet.namespace, packet.node), None)
120		if packethandler is None:
121		packethandler = self.RoutedPacketHandlers.get((packet.namespace, ), None)
122		if packethandler is None:
123		packethandler = self.RoutedPacketHandlers.get(None, None)
124		if packethandler is None:
	120	for nodeidx in self._GetPacketHandlerIndices((packet.namespace, packet.node)):
	121	packethandler = self.RoutedPacketHandlers.get(nodeidx, None)
	122	if packethandler is not None: break
	123	else:
125	124	raise ErrorTypes.RoutedHandlerError("No RoutedPacketHandler for (%s, %s)" % (packet.namespace, packet.node))
126	125
…	…
131	130
132	131	# Lookup our packet handler
133		packethandler = self.StreamPacketHandlers.get((packet.namespace, packet.node), None)
134		if packethandler is None:
135		packethandler = self.StreamPacketHandlers.get((packet.namespace, ), None)
136		if packethandler is None:
137		packethandler = self.StreamPacketHandlers.get(None, None)
138		if packethandler is None:
	132	for nodeidx in self._GetPacketHandlerIndices((packet.namespace, packet.node)):
	133	packethandler = self.StreamPacketHandlers.get(nodeidx, None)
	134	if packethandler is not None: break
	135	else:
139	136	raise ErrorTypes.PacketHandlerError("No StreamPacketHandler for (%s, %s)" % (packet.namespace, packet.node))
140	137
…	…
144	141	self.log.debug('Stream shutdown by "%s"', how)
145	142
	143	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	144	#~ Protected Methods
	145	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	146
	147	def _GetPacketHandlerIndices(self, (namespace, node)):
	148	yield (namespace, node)
	149	yield (namespace, )
	150	yield node
	151	yield None
	152

trunk/RBTelepathy/RBTelepathy/Handlers/init.py

r458	r463
40	40	None: 'the default namespace when one is not specified'}
41	41	DefaultNamespace = NamespaceSynonyms[None]
42		ElementFactories = ~~Elemen~~tFactorySet({
	42	ElementFactories = PacketFactorySet({
43	43	(namespace, node0): ElementFactory(...), # Specific (namespace, node)
44	44	(namespace, nodeN): ElementFactory(...), # Specific (namespace, node)

trunk/RBTelepathy/RBTelepathy/Packet/Builder.py

r455	r463
24	24	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25	25
	26	from __future__ import generators
26	27	import weakref
27		~~from __init__ import RBNamespaceSynonyms~~
28	28	from xml.parsers.expat import ExpatError
29		from RBFoundation.XMLClassBuilder import *
30		from RBFoundation.XMLClassBuilder import ElementFactory as EF
	29	#from RBFoundation.XMLClassBuilder import *
	30	#from RBFoundation.XMLClassBuilder import ElementFactory as EF
	31	from RBFoundation import XMLClassBuilder
31	32	from RBTelepathy import ErrorTypes
	33
	34	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	35	#~ Constants / Variables / Etc.
	36	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	37
	38	EF = XMLClassBuilder.ElementFactory
	39	XMLClassBuilderObjectMixin = XMLClassBuilder.XMLClassBuilderObjectMixin
32	40
33	41	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
47	55	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
48	56
49		class StreamPacketBuilder(XMLClassBuilder):
	57	class PacketFactorySet(XMLClassBuilder.ElementFactorySet):
	58	def _GetElementFactoryIndices(self, (namespace, node)):
	59	yield (namespace, node)
	60	yield (namespace, )
	61	yield node
	62	yield None
	63
	64	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	65
	66	class StreamPacketBuilder(XMLClassBuilder.XMLClassBuilder):
50	67	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
51	68	#~ Constants / Variables / Etc.
52	69	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
53	70
54		NamespaceSynonyms = RBNamespaceSynonyms
55		DefaultNamespace = RBNamespaceSynonyms[None]
	71	ElementFactories = PacketFactorySet()
56	72
57	73	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
77	93	def _xmlChildFactory(self, owner, parent, node, attributes, namespacemap):
78	94	try:
79		XMLClassBuilder._xmlChildFactory(self, owner, parent, node, attributes, namespacemap)
	95	XMLClassBuilder.XMLClassBuilder._xmlChildFactory(self, owner, parent, node, attributes, namespacemap)
80	96	except KeyError, e:
81	97	# Well, we don't seem to have a packet for that... Error! =)

trunk/RBTelepathy/RBTelepathy/Packet/init.py

r455	r463
20	20	##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
21	21
22		~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23		~~#~ Constants / Variables / Etc.~~
24		~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25
26		~~RBTelepathyNamespace = 'http://namespaces.runeblade.com/RBTelepathy'~~
27		~~RBNamespaceSynonyms = {~~
28		~~'RuneBladeMessaging': RBTelepathyNamespace,~~
29		~~'RBTelepathy': RBTelepathyNamespace,~~
30		~~'RBM': RBTelepathyNamespace,~~
31		~~None: RBTelepathyNamespace,~~
32		}
33		~~RBDefaultNamespace = RBNamespaceSynonyms[None]~~
34

trunk/RBTelepathy/demo/simple/client/AuthenticationHandler.py

r458	r463
49	49	NamespaceSynonyms = {None: DefaultNamespace}
50	50	DefaultNamespace = NamespaceSynonyms[None]
51		ElementFactories = ~~Elemen~~tFactorySet({
	51	ElementFactories = PacketFactorySet({
52	52	(DefaultNamespace, 'response'): Elements.Factory(Elements.PacketElement),
53	53	(DefaultNamespace, 'challenge'): Elements.Factory(Elements.PacketElement),
…	…
94	94	NamespaceSynonyms = {None: DefaultNamespace}
95	95	DefaultNamespace = NamespaceSynonyms[None]
96		ElementFactories = ~~Elemen~~tFactorySet({
	96	ElementFactories = PacketFactorySet({
97	97	(DefaultNamespace, 'as'): Elements.Factory(Elements.URIAddressElement),
98	98	(DefaultNamespace, 'method'): Elements.Factory(method),

trunk/RBTelepathy/demo/simple/client/ErrorHandler.py

r458	r463
40	40	NamespaceSynonyms = {None: DefaultNamespace}
41	41	DefaultNamespace = NamespaceSynonyms[None]
42		ElementFactories = ~~Elemen~~tFactorySet({
	42	ElementFactories = PacketFactorySet({
43	43	(DefaultNamespace, ): Elements.Factory(Elements.PacketElement),
44	44	})

trunk/RBTelepathy/demo/simple/client/MessageHandler.py

r458	r463
45	45	NamespaceSynonyms = {None: DefaultNamespace}
46	46	DefaultNamespace = NamespaceSynonyms[None]
47		ElementFactories = ~~Elemen~~tFactorySet({
	47	ElementFactories = PacketFactorySet({
48	48	(DefaultNamespace, 'to'): Elements.Factory(Elements.URIAddressElement),
49	49	(DefaultNamespace, 'from'): Elements.Factory(Elements.URIAddressElement),

trunk/RBTelepathy/demo/simple/host/AuthenticationHandler.py

r458	r463
40	40	NamespaceSynonyms = {None: DefaultNamespace}
41	41	DefaultNamespace = NamespaceSynonyms[None]
42		ElementFactories = ~~Elemen~~tFactorySet({
	42	ElementFactories = PacketFactorySet({
43	43	(DefaultNamespace, 'response'): Elements.Factory(Elements.PacketElement),
44	44	(DefaultNamespace, 'challenge'): Elements.Factory(Elements.PacketElement),
…	…
124	124	NamespaceSynonyms = {None: DefaultNamespace}
125	125	DefaultNamespace = NamespaceSynonyms[None]
126		ElementFactories = ~~Elemen~~tFactorySet({
	126	ElementFactories = PacketFactorySet({
127	127	(DefaultNamespace, 'as'): Elements.Factory(Elements.URIAddressElement),
128	128	(DefaultNamespace, 'method'): Elements.Factory(DefaultAuthMethod),

trunk/RBTelepathy/demo/simple/host/ErrorHandler.py

r458	r463
40	40	NamespaceSynonyms = {None: DefaultNamespace}
41	41	DefaultNamespace = NamespaceSynonyms[None]
42		ElementFactories = ~~Elemen~~tFactorySet({
	42	ElementFactories = PacketFactorySet({
43	43	(DefaultNamespace, ): Elements.Factory(Elements.PacketElement),
44	44	})

trunk/RBTelepathy/demo/simple/host/MessageHandler.py

r458	r463
45	45	NamespaceSynonyms = {None: DefaultNamespace}
46	46	DefaultNamespace = NamespaceSynonyms[None]
47		ElementFactories = ~~Elemen~~tFactorySet({
	47	ElementFactories = PacketFactorySet({
48	48	(DefaultNamespace, 'to'): Elements.Factory(Elements.URIAddressElement),
49	49	(DefaultNamespace, 'from'): Elements.Factory(Elements.URIAddressElement),

Navigation

Changeset 463

Legend:

Download in other formats: