I assume the typo on the last line isn't in your actual code 
(server.serve_forever()).  But yes, this won't work.  server.serve_forever() 
will block forever, freezing NOX.  And you can't just put it in another thread 
because that will crash or hang or cause other bad things to happen in NOX.

You should be able to make this work by setting the server timeout to 0, and 
periodically calling its handle_request() inside a timer you'd created with 
post_callback().  However, this essentially would poll for requests at some 
rate and is not a terribly efficient or elegant solution, and I wouldn't 
suggest doing it if you don't have to...

And I don't think you have to -- the recommended way to do XML-RPC in NOX would 
be to use Twisted.  The following page has some info on doing XML-RPC in 
Twisted:
http://twistedmatrix.com/documents/current/web/howto/xmlrpc.html

That might more or less just work in NOX.  If it doesn't, take a look in NOX's 
webserver.py to fill in any blanks.

Hope that helps.

-- Murphy

On Aug 20, 2011, at 12:26 AM, chris oleke wrote:

> Hi, I've got another question still related to my NOX application. It is 
> supposed to receive replies from the third party application through use of 
> XML-RPC. I have had a go at the SimpleXMLRPCServer but seem to have no 
> connection established, my thought is that I'm calling it the wrong way. This 
> is how I call it from my application
> 
> def run(self):
>         self.server = SimpleXMLRPCServer(("localhost", 8080), 
> requestHandler=RequestHandler)
>         self.register_introspection_functions()
>         self.register_function(test_xml, 'reply_one.test')
>         server.server_forever()
> 
> test_xml is a function  defined within my application. Any help I can get 
> will be highly appreciated.
> 
> Regards,
> Chris
> 
> 
> On Tue, Aug 16, 2011 at 7:38 AM, chris oleke <chrisol...@gmail.com> wrote:
> Thanks Murphy!! I have tried testing it and I can receive the Hello World 
> continuously on my other application. But since I'm sending the flows from a 
> separate function, I have made some modifications and called the sock.connect 
> from my component's init() and I can receive the flows continuously.    
> 
> On Tue, Aug 16, 2011 at 6:44 AM, Murphy McCauley <jam...@nau.edu> wrote:
> If the application you're working with requires that you close the socket, 
> then it seems like you should be creating, connecting, sending on, and 
> closing a new socket every ten seconds in response to your flow stats coming 
> in.
> 
> It looks like you may be not creating and connecting a new socket after the 
> first run, and are trying to reuse a socket that you'd closed (made possible 
> by the fact that you're saving a reference to an old one as self.sock, which 
> you can never actually reuse since you close it).
> 
> I put the following code in an app (and then kick it off by calling it in my 
> Component's install()), and it seems to work just fine:
> 
> def handle_timer (self):
>   import socket
>   self.post_callback(5, self.handle_timer)
>   sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
>   sock.connect(("",5000))
>   sock.send("Hello world!\n")
>   sock.close()
> 
> Can you test if this seems to work for you?  (I just run "nc -lk 5000" to 
> give it something to connect to.)
> 
> As a sidenote: These calls are blocking, and it's not nice to block the 
> thread.  Using Twisted is the preferred solution.  But since this is only 
> periodic and is connecting to localhost, etc., I am not sure that's worth 
> worrying about.  As I said, it has been a long time since I have looked at 
> NOX's threading stuff, but nothing immediately comes to mind about why this 
> wouldn't work.
> 
> -- Murphy
> 
> On Aug 15, 2011, at 2:15 PM, chris oleke wrote:
> 
>> Murphy, the thing is I'd pretty much want to maintain the sockets that I'm 
>> using at the moment since the third party application is tailored to work 
>> with them. When I send the data from NOX, I have to close the sockets 
>> because the data won't be received on the other end if the sockets remain 
>> open. My flow stats are generated every 10 seconds so my aim is to have them 
>> sent continously. I had previously tried using sock.setblocking(0) but 
>> encountered an error "operation already in progress" so abandoned using it.
>> 
>> On Sat, Aug 13, 2011 at 2:34 AM, Murphy McCauley <jam...@nau.edu> wrote:
>> It has been long enough since I've looked at the co-op threading in NOX that 
>> I don't immediately know what the problem you're having with the file 
>> descriptors going away is.  You're sure you're not calling close() on them?  
>> You could try setting the socket to non-blocking mode with 
>> sock.setblocking(0).
>> 
>> It might be possible to get asynccore to work, but I think it'd probably be 
>> some trouble.  Twisted, on the other hand, should more or less just work.  I 
>> think you can probably look at the NOX webservice stuff for a bit of an 
>> example, but it shouldn't be much different than any other Twisted code.
>> 
>> Or if you would be okay with communicating with the other process via JSON 
>> strings, you could use jsonmessenger.  Look in monitoring.py from the 
>> monitoring component for an example.
>> 
>> Hope that helps.
>> 
>> -- Murphy
>> 
>> On Aug 12, 2011, at 2:03 PM, chris oleke wrote:
>> 
>>> Hi
>>> 
>>> 
>>> 
>>> Hopefully this is still within the Nox domain. I have a python application 
>>> that is using sockets to send out flows that I have obtained from a 
>>> flow_stats_in_event to an application external of Nox. This is how I’m 
>>> doing it
>>> 
>>> self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
>>> self.sock.connect(("",5000))
>>> self.sock.send(repr(flows))
>>> self.sock.close()
>>> 
>>> Unfortunately I can only send the flows once before the sockets close after 
>>> which I get the errors below
>>> 
>>> self.sock.send(repr(flows))
>>>   File "/usr/lib/python2.6/socket.py", line 167, in _dummy
>>>     raise error(EBADF, 'Bad file descriptor')
>>> error: [Errno 9] Bad file descriptor
>>>  
>>> It’s obviously as a result of trying to send information out on a socket 
>>> that’s been closed. I have tried to look at asyncore and see if I can have 
>>> an asynchronous socket but haven’t had any luck and my application’s seems 
>>> to lock/freeze the few times I have tried. Is there a way I can have the 
>>> socket remain connected so I can have flows sent constantly and also be 
>>> able to receive data when sent from the external application. I would like 
>>> a demonstration as well if it’s possible.
>>> 
>>> 
>>> 
>>> Thanks
>>> 
>>> Chris
>>> 
>>> _______________________________________________
>>> nox-dev mailing list
>>> nox-dev@noxrepo.org
>>> http://noxrepo.org/mailman/listinfo/nox-dev
>> 
>> 
> 
> 
> 

_______________________________________________
nox-dev mailing list
nox-dev@noxrepo.org
http://noxrepo.org/mailman/listinfo/nox-dev

Reply via email to