Webware for Python

On Tuesday 26 October 2004 05:46, Lincoln Han wrote:
> Thank you all for the prompt response, I have spent days trying to
> figure this out before I finally decided it's time to ask the experts.
>
> My Apache is Apache/2.0.48 on Linux and latest version of webware 0.8.1
>
> The site I am having problem is http://www.unlockcellphone.com
>
> The problem I had was everything was tested by one person at a time,
> not simultaneously. It is when i had another friend testing it
> simultaneously I discovered this session problem. Other than this
> particular problem, the site is working very well.
>
> If you can be kind enough to take a look at part of the cart
> code, I would really appreciate it.
>
>
> I don't have a __init__() function defined in the Cart and if that could be
> a problem
> please let me know.
>
> Regards,
>
> Lincoln
>
>

In addition what Geoff just wrote:
you have for example the line 
sess.setValue('currentCart', self.itemlist)
which sets a link to on instance variable to the session object. The 
'self.itemlist' might be end up in some other 'Page' as well.
Instance attributes might outlive a specific page as they are recycled.

Hope that helps

Stephan

Lincoln Han wrote:

> 
> class Cart(Page, BasicItem, ExtendedItem, Shipping):
> 
> 
>     customer = Customer()           #store the customer info into the 
> customer object at check out
>     order = Order()                 #we will need to store the order 
> into the order object at check out
>     itemlist = list()
>     subtotal = 0.00
>     shipping = Shipping()           #Shipping object is part of the 
> WebObjects class

I didn't read furher, but the above is a prominent sign IMO.

Your order, customer and other objects are class variables!
That means they would be shared for all Cart servlet instances.

You must not put an "order" even to a servlet variable, not to mention 
class var but store them in Session object. For those that can't be 
stored there (as they, say, contains a db connection or simply not 
pickable) you could use, say, a global dict (singleton)

Here is a version I wrote to address this issue (attached).

It looks like the customer and it's related items are being set as 
*class* variables instead of *instance* attributes.

Class variables will be shared across all instances.  All of the code 
in the various page methods are manipulating the same variable in the 
class.  You're going to have to extract the customer and itemlist 
instantiations into some other place.  Maybe in the page's awake method 
you could check the user's session object to see if they have a 
customer and itemlist object set already, if not, create them and put 
them into the session object:
	
	def awake(self, transaction):
		Page.awake(self, transaction)
		if not self.session().hasValue('customer'):
			self.session().setValue('customer', Customer())
		if not self.session().hasValue('order'):
			self.session().setValue('order', Order())
		etc...

Then, in all your logic/manipulation code, first get the object you 
want to manipulate and then do what you need, i.e.:

	def test(self):
		order = self.session().value('order')
		order.addSomething(...)

But, you're going to have to put *everything* that is customer-specific 
into a session variable.  It might be worth it to abstract out a larger 
container class that has an API into all of the sub-components...

--T

On Oct 25, 2004, at 10:46 PM, Lincoln Han wrote:

> class Cart(Page, BasicItem, ExtendedItem, Shipping):
>
>     ValidationError = 'ValidationError'
>     connInfo = 'hostaddr=127.0.0.1 port=5432 dbname=moewhouse 
> user=frog password=green'
>
>     customer = Customer()           #store the customer info into the 
> customer object at check out
>     order = Order()                 #we will need to store the order 
> into the order object at check out
>     itemlist = list()
>     subtotal = 0.00
>     shipping = Shipping()           #Shipping object is part of the 
> WebObjects class
>     total = 0.00
>     payTax = False

Thanks for all who replied with good answers. I am working on fixing this 
problem.
Now I am curious about the technical design of the servlet. I wrongfully 
assumed
that a new servlet is loaded per connection, now I understood it is not the 
case.
Because the servlet is re-used, that's why whatever I declare as part of 
the class of the
servlet is shared by different connections. Since the servlet is loaded 
once and shared
among all connections, what are the exact parts that explicitly tells the 
servlet to keep
the data unique to the connection - I assume this would be the session 
right? Is it better
to put the non-shared data into __init__ (which is still part of the 
servlet class) or awake() ?

Lincoln

Lincoln H. wrote:
> Thanks for all who replied with good answers. I am working on fixing 
> this problem.
> Now I am curious about the technical design of the servlet. I wrongfully 
> assumed
> that a new servlet is loaded per connection, now I understood it is not 
> the case.
> Because the servlet is re-used, that's why whatever I declare as part of 
> the class of the
> servlet is shared by different connections. Since the servlet is loaded 
> once and shared
> among all connections, what are the exact parts that explicitly tells 
> the servlet to keep
> the data unique to the connection - I assume this would be the session 
> right? Is it better
> to put the non-shared data into __init__ (which is still part of the 
> servlet class) or awake() ?
> 
> Lincoln

Hi Lincoln,

__init__() is called at webware startup (when it first loads the 
servlet). whatever you put in here persists for the duration of the 
servlet's lifetime. the servlet's lifetime could be equal to the webware 
server's lifetime (weeks, months, years).

awake() is called when the servlet is woken up for a new request. any 
request specific initialization should be done here. this will of course 
persist along with the servlet just like __init__, so...

sleep() is called when the servlet is finished handling a request. you 
need to make sure to clean up any variables etc. that were set during 
awake or during the process of the request. do whatever you need to do 
to clean up for the next request.

Recap:

__init__ - set up servlet on app server startup - runs only once
awake() - set up request - runs once per request
sleep() - clean up request - runs once per request

to put this all together, here is a simple example from one of my 
SitePage classfiles:


     def awake(self, transaction):
         Page.awake(self, transaction)
         self.script_uri = self.request().serverDictionary()['SCRIPT_URI']
         self.success = ''
         self.error = ''
         self.message = ''

     def sleep(self, transaction):
         self.mysql.Disconnect()
         Page.sleep(self, transaction)



and here is the source code from the webkit Page classfile:


     def awake(self, transaction):
         HTTPServlet.awake(self, transaction)
         self._response    = transaction.response()
         self._request     = transaction.request()
         self._session     = None  # don't create unless needed
         assert self._transaction is not None
         assert self._response    is not None
         assert self._request     is not None


As you can see, it is important to call the parent's awake method - 
Page.awake() - if you override awake. Same goes for sleep.

Hope this helps you to get an idea about the design/flow of webkit. I 
find that a little time spent browsing the webkit source code 
(especially Page, Session, and other well used classes) really helps my 
understanding of how the framework works.

Considering that the python code is well written and fairly simple, and 
that to use webkit we actually *extend* it, the source code presents 
itself as the best documentation for this project.

- Sam Nilsson