version 1.3, 2004/03/26 14:19:50
|
version 1.4, 2004/03/30 13:56:24
|
Line 1
|
Line 1
|
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.PageTemplate import PageTemplate |
from Products.PageTemplates.PageTemplate import PageTemplate |
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate |
|
from OFS.Image import Image |
|
from webdav.common import rfc1123_date |
|
|
import xml.dom.minidom |
import xml.dom.minidom |
from OFS.Folder import Folder |
from OFS.Folder import Folder |
Line 115 def readNavTemp(fileName):
|
Line 116 def readNavTemp(fileName):
|
navTag=None |
navTag=None |
return navTag |
return navTag |
|
|
|
class zogiImage(Image): |
|
"""einzelnes Image""" |
|
meta_type="zogiImage" |
|
|
|
|
|
|
|
def __init__(self,id,title,baseUrl,queryString,content_type='',precondition=''): |
|
"""init""" |
|
self.id=id |
|
self.title=title |
|
self.baseUrl=baseUrl |
|
self.queryString=queryString |
|
self.content_type=content_type |
|
self.precondition=precondition |
|
|
|
def getData(self): |
|
"""getUrlData""" |
|
return urllib.urlopen(self.baseUrl+self.queryString) |
|
|
|
def changeZogiImageForm(self): |
|
"""Main configuration""" |
|
pt=PageTemplateFile('Products/zogiLib/zpt/changeZogiImageForm.zpt').__of__(self) |
|
return pt() |
|
|
|
def changeZogiImage(self,title,baseUrl, queryString,RESPONSE=None): |
|
"""change it""" |
|
self.title=title |
|
self.baseUrl=baseUrl |
|
self.queryString=queryString |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
|
|
manage_options=ZopePageTemplate.manage_options+( |
|
{'label':'Main config','action':'changeZogiImageForm'}, |
|
) |
|
|
|
|
|
|
|
|
|
def index_html(self, REQUEST, RESPONSE): |
|
""" |
|
Modified version of OFS/Image.py |
|
|
|
The default view of the contents of a File or Image. |
|
|
|
Returns the contents of the file or image. Also, sets the |
|
Content-Type HTTP header to the objects content type. |
|
""" |
|
|
|
# HTTP If-Modified-Since header handling. |
|
header=REQUEST.get_header('If-Modified-Since', None) |
|
if header is not None: |
|
header=header.split( ';')[0] |
|
# Some proxies seem to send invalid date strings for this |
|
# header. If the date string is not valid, we ignore it |
|
# rather than raise an error to be generally consistent |
|
# with common servers such as Apache (which can usually |
|
# understand the screwy date string as a lucky side effect |
|
# of the way they parse it). |
|
# This happens to be what RFC2616 tells us to do in the face of an |
|
# invalid date. |
|
try: mod_since=long(DateTime(header).timeTime()) |
|
except: mod_since=None |
|
if mod_since is not None: |
|
if self._p_mtime: |
|
last_mod = long(self._p_mtime) |
|
else: |
|
last_mod = long(0) |
|
if last_mod > 0 and last_mod <= mod_since: |
|
# Set header values since apache caching will return Content-Length |
|
# of 0 in response if size is not set here |
|
RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', self.size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
self.ZCacheable_set(None) |
|
RESPONSE.setStatus(304) |
|
return '' |
|
|
|
if self.precondition and hasattr(self,self.precondition): |
|
# Grab whatever precondition was defined and then |
|
# execute it. The precondition will raise an exception |
|
# if something violates its terms. |
|
c=getattr(self,self.precondition) |
|
if hasattr(c,'isDocTemp') and c.isDocTemp: |
|
c(REQUEST['PARENTS'][1],REQUEST) |
|
else: |
|
c() |
|
|
|
# HTTP Range header handling |
|
range = REQUEST.get_header('Range', None) |
|
request_range = REQUEST.get_header('Request-Range', None) |
|
if request_range is not None: |
|
# Netscape 2 through 4 and MSIE 3 implement a draft version |
|
# Later on, we need to serve a different mime-type as well. |
|
range = request_range |
|
if_range = REQUEST.get_header('If-Range', None) |
|
if range is not None: |
|
ranges = HTTPRangeSupport.parseRange(range) |
|
|
|
if if_range is not None: |
|
# Only send ranges if the data isn't modified, otherwise send |
|
# the whole object. Support both ETags and Last-Modified dates! |
|
if len(if_range) > 1 and if_range[:2] == 'ts': |
|
# ETag: |
|
if if_range != self.http__etag(): |
|
# Modified, so send a normal response. We delete |
|
# the ranges, which causes us to skip to the 200 |
|
# response. |
|
ranges = None |
|
else: |
|
# Date |
|
date = if_range.split( ';')[0] |
|
try: mod_since=long(DateTime(date).timeTime()) |
|
except: mod_since=None |
|
if mod_since is not None: |
|
if self._p_mtime: |
|
last_mod = long(self._p_mtime) |
|
else: |
|
last_mod = long(0) |
|
if last_mod > mod_since: |
|
# Modified, so send a normal response. We delete |
|
# the ranges, which causes us to skip to the 200 |
|
# response. |
|
ranges = None |
|
|
|
if ranges: |
|
# Search for satisfiable ranges. |
|
satisfiable = 0 |
|
for start, end in ranges: |
|
if start < self.size: |
|
satisfiable = 1 |
|
break |
|
|
|
if not satisfiable: |
|
RESPONSE.setHeader('Content-Range', |
|
'bytes */%d' % self.size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
RESPONSE.setHeader('Last-Modified', |
|
rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', self.size) |
|
RESPONSE.setStatus(416) |
|
return '' |
|
|
|
ranges = HTTPRangeSupport.expandRanges(ranges, self.size) |
|
|
|
if len(ranges) == 1: |
|
# Easy case, set extra header and return partial set. |
|
start, end = ranges[0] |
|
size = end - start |
|
|
|
RESPONSE.setHeader('Last-Modified', |
|
rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
RESPONSE.setHeader('Content-Range', |
|
'bytes %d-%d/%d' % (start, end - 1, self.size)) |
|
RESPONSE.setStatus(206) # Partial content |
|
|
|
data = urllib.urlopen(self.baseUrl+self.queryString).read() |
|
if type(data) is StringType: |
|
return data[start:end] |
|
|
|
# Linked Pdata objects. Urgh. |
|
pos = 0 |
|
while data is not None: |
|
l = len(data.data) |
|
pos = pos + l |
|
if pos > start: |
|
# We are within the range |
|
lstart = l - (pos - start) |
|
|
|
if lstart < 0: lstart = 0 |
|
|
|
# find the endpoint |
|
if end <= pos: |
|
lend = l - (pos - end) |
|
|
|
# Send and end transmission |
|
RESPONSE.write(data[lstart:lend]) |
|
break |
|
|
|
# Not yet at the end, transmit what we have. |
|
RESPONSE.write(data[lstart:]) |
|
|
|
data = data.next |
|
|
|
return '' |
|
|
|
else: |
|
boundary = choose_boundary() |
|
|
|
# Calculate the content length |
|
size = (8 + len(boundary) + # End marker length |
|
len(ranges) * ( # Constant lenght per set |
|
49 + len(boundary) + len(self.content_type) + |
|
len('%d' % self.size))) |
|
for start, end in ranges: |
|
# Variable length per set |
|
size = (size + len('%d%d' % (start, end - 1)) + |
|
end - start) |
|
|
|
|
|
# Some clients implement an earlier draft of the spec, they |
|
# will only accept x-byteranges. |
|
draftprefix = (request_range is not None) and 'x-' or '' |
|
|
|
RESPONSE.setHeader('Content-Length', size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
RESPONSE.setHeader('Last-Modified', |
|
rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', |
|
'multipart/%sbyteranges; boundary=%s' % ( |
|
draftprefix, boundary)) |
|
RESPONSE.setStatus(206) # Partial content |
|
|
|
data = urllib.urlopen(self.baseUrl+self.queryString).read() |
|
# The Pdata map allows us to jump into the Pdata chain |
|
# arbitrarily during out-of-order range searching. |
|
pdata_map = {} |
|
pdata_map[0] = data |
|
|
|
for start, end in ranges: |
|
RESPONSE.write('\r\n--%s\r\n' % boundary) |
|
RESPONSE.write('Content-Type: %s\r\n' % |
|
self.content_type) |
|
RESPONSE.write( |
|
'Content-Range: bytes %d-%d/%d\r\n\r\n' % ( |
|
start, end - 1, self.size)) |
|
|
|
if type(data) is StringType: |
|
RESPONSE.write(data[start:end]) |
|
|
|
else: |
|
# Yippee. Linked Pdata objects. The following |
|
# calculations allow us to fast-forward through the |
|
# Pdata chain without a lot of dereferencing if we |
|
# did the work already. |
|
first_size = len(pdata_map[0].data) |
|
if start < first_size: |
|
closest_pos = 0 |
|
else: |
|
closest_pos = ( |
|
((start - first_size) >> 16 << 16) + |
|
first_size) |
|
pos = min(closest_pos, max(pdata_map.keys())) |
|
data = pdata_map[pos] |
|
|
|
while data is not None: |
|
l = len(data.data) |
|
pos = pos + l |
|
if pos > start: |
|
# We are within the range |
|
lstart = l - (pos - start) |
|
|
|
if lstart < 0: lstart = 0 |
|
|
|
# find the endpoint |
|
if end <= pos: |
|
lend = l - (pos - end) |
|
|
|
# Send and loop to next range |
|
RESPONSE.write(data[lstart:lend]) |
|
break |
|
|
|
# Not yet at the end, transmit what we have. |
|
RESPONSE.write(data[lstart:]) |
|
|
|
data = data.next |
|
# Store a reference to a Pdata chain link so we |
|
# don't have to deref during this request again. |
|
pdata_map[pos] = data |
|
|
|
# Do not keep the link references around. |
|
del pdata_map |
|
|
|
RESPONSE.write('\r\n--%s--\r\n' % boundary) |
|
return '' |
|
|
|
RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime)) |
|
RESPONSE.setHeader('Content-Type', self.content_type) |
|
RESPONSE.setHeader('Content-Length', self.size) |
|
RESPONSE.setHeader('Accept-Ranges', 'bytes') |
|
|
|
# Don't cache the data itself, but provide an opportunity |
|
# for a cache manager to set response headers. |
|
self.ZCacheable_set(None) |
|
|
|
data=urllib.urlopen(self.baseUrl+self.queryString).read() |
|
|
|
if type(data) is type(''): |
|
RESPONSE.setBase(None) |
|
return data |
|
|
|
while data is not None: |
|
RESPONSE.write(data.data) |
|
data=data.next |
|
|
|
return '' |
|
|
|
|
|
def manage_addZogiImageForm(self): |
|
"""Form for adding""" |
|
pt=PageTemplateFile('Products/zogiLib/zpt/addZogiImage.zpt').__of__(self) |
|
return pt() |
|
|
|
|
|
def manage_addZogiImage(self,id,title,baseUrl, queryString,RESPONSE=None): |
|
"""add dgilib""" |
|
newObj=zogiImage(id,title,baseUrl, queryString) |
|
self.Destination()._setObject(id,newObj) |
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
|
|
|
class zogiLib(Folder): |
class zogiLib(Folder): |
"""StandardElement""" |
"""StandardElement""" |