Grok and XML-RPC
XML-RPC using Grok:
What is XML-RPC ? From the site (http://xmlrpc.com): It's a spec and a set of implementations that allow software running on disparate operating systems, running in different environments to make procedure calls over the Internet.
So, What is Grok? From the site : Grok is a web application framework for Python developers. It is aimed at both beginners and very experienced web developers. Grok has an emphasis on agile development. Grok is easy and powerful. Grok accomplishes this by being based on Zope 3, an advanced object-oriented web framework. While Grok is based on Zope 3, and benefits a lot from it, you do not need to know Zope at all in order to get productive with Grok. So, it is cool, isn't it :)
To install the latest grok , give the following command ,
This will download and install grok for you. After this we are ready to rock ...
Creating our first project:
Let's create the project named "Foo". For that give the command
This will create a subdirectory in the current directory named "Foo", then it will download Zope3 and install Grok with that which you can start working with. It will ask you a few questions like: "Enter module (Name of a demo Python module placed into the package) ['app.py']: " Press Enter for the default value Then , "Enter user (Name of an initial administrator user): foo Enter passwd (Password for the initial administrator user): foo" We typed "foo" for both the user and password.
Starting up Zope:
Switch to the Foo directory, and give the command
This will startup Zope for you , you can access it through a web browser pointing to http://localhost:8080/
Then add an application named foo. You can access it by http://localhost:8080/foo , it will show
Congratulations! Your Grok application is up and running. Edit foo/app_templates/index.pt to change this page.
Now we are going to write our xmlrpc stuffs inside it.
Now you can open the file src/foo/app.py in a text editor. The default is give below :
import grok class Foo(grok.Application, grok.Container): pass class Index(grok.View): pass # see app_templates/index.pt
We will another class which will be available through this application class, the new class should inherit grok.XMLRPC for this , and we will write a say() method. It will return "Hello World!". So, the changed file:
import grok class Foo(grok.Application, grok.Container): pass class Index(grok.View): pass # see app_templates/index.pt class FooXMLRPC(grok.XMLRPC): """The methods in this class will be available as XMLRPC methods on 'Foo' applications.""" def say(self): return 'Hello world!'
The name of the class doesn't matter , so you can give any name to that. Restart the Zope in the console, and you can connect to it through any xmlrpc client. Below is an example (fooclient.py):
#!/usr/bin/env python import xmlrpclib s = xmlrpclib.Server('http://localhost:8080/foo') print s.say()
Run this and see !!
Class in a different file:
What if you want to write the class in a different file in the src/foo directory and still want to have the methods to be available under Foo application. For that you need to tell grok explicitly that the new class to associate it to the Foo model by using the grok.context class annotation.
What is a class annotation? A class annotation is a declarative way to tell grok something about a Python class. Let's see the example, we will write a Boom.py with a Boom class.
import grok from app import Foo class Boom(grok.XMLRPC): grok.context(Foo) def dance(self): return "Boom is dancing!!"
Look at the line where it says "grok.context(Foo)" this is doing all the magic. In the fooclient.py you just need to call s.dance instead of s.say().
So, now write your dream system .... :D