def autoping(name):
request = Request()
# Load up the cache (You can just import the base cache here)
cache_driver = tools.importName('Pyblosxom.cache', config.py.get('cacheDriver', 'base'))
cache = cache_driver.BlosxomCache(request, config.py.get('cacheConfig', ''))
try:
filename = os.path.join(config.py['datadir'], name)
entryData = {}
cache.load(filename)
# Look for cached documents
if cache.isCached():
entryData = cache.getEntry()
# Cached? Try our entryparsers then.
if not entryData:
fileExt = re.search(r'\.([\w]+)$', filename)
try:
entryData = blosxom_entry_parser(filename, request)
except IOError, e:
tools.log(e)
name = re.sub(config.py['datadir'],'',name)
parser = link(name, entryData['title'].strip(), entryData['body'].strip(), config.py['blog_title'])
trackback(parser)
pingback(parser)
def cb_handle(args):
request = args['request']
config = request.getConfiguration()
path = request.getHttp().get('PATH_INFO', '')
tools.log('%s' % (path))
if path.lower() == ADMINPAGE:
comments_admin(request)
return 1
return 0
def cb_handle(args):
request = args['request']
config = request.getConfiguration()
path = request.getHttp().get('PATH_INFO', '')
tools.log('%s' % (path))
if path.lower() == ADMINPAGE:
comments_admin(request)
return 1
return 0
def readComments(entry, config):
"""
@param: a file entry
@type: dict
@returns: a list of comment dicts
"""
filelist = glob.glob(cmtExpr(entry, config))
filelist.sort()
if not entry.has_key('num_comments'):
entry['num_comments'] = len(filelist)
try:
return [readComment(f) for f in filelist]
except:
tools.log("Couldn't read comments for entry: ", entry)
return []
def readComments(entry, config):
"""
@param: a file entry
@type: dict
@returns: a list of comment dicts
"""
filelist = glob.glob(cmtExpr(entry, config))
filelist.sort()
if not entry.has_key('num_comments'):
entry['num_comments'] = len(filelist)
try:
return [ readComment(f) for f in filelist ]
except:
tools.log("Couldn't read comments for entry: ",entry)
return []
def readComment(filename):
"""
Read a comment from filename
@param: filename containing a comment
@type: string
@returns: a comment dict
"""
from xml.sax import make_parser, SAXException
from xml.sax.handler import feature_namespaces, ContentHandler
class cmtHandler(ContentHandler):
def __init__(self, cmt):
self._data = ""
self.cmt = cmt
def startElement(self, name, atts):
self._data = ""
def endElement(self, name):
self.cmt['cmt_' + name] = self._data
def characters(self, content):
self._data += content
cmt = {}
try:
story = open(filename)
parser = make_parser()
parser.setFeature(feature_namespaces, 0)
handler = cmtHandler(cmt)
parser.setContentHandler(handler)
parser.parse(story)
#story.close()
cmt['cmt_time'] = cmt['cmt_pubDate']
# timestamp as float for comment anchor
cmt['cmt_pubDate'] = time.ctime(float(cmt['cmt_pubDate']))
story.close()
except:
tools.log("Couldn't read: ", filename)
story.close()
return cmt
def trackback(parser):
""" parser -> None
Ping all trackbacks encountered with the url, title, blog_name, and
excerpt.
"""
for url in parser.trackbacks:
try:
tools.log("")
tools.log( "*** Trackback " + url)
tools.log(parser.args)
if url.find('?tb_id=') >= 0:
file=urllib.urlopen(url + "&" + parser.args)
else:
file=urllib.urlopen(url, parser.args)
tools.log(file.read())
file.close()
except Exception, e:
tools.log(e)
def pingback(parser):
""" parser -> None
Ping all pingbacks encountered with the source and targets
"""
for target,server in parser.pingbacks:
try:
tools.log("")
tools.log("*** Pingback " + server)
server=xmlrpclib.Server(server)
tools.log(server.pingback.ping(parser.url,target))
except Exception, e:
tools.log(e)
def readComment(filename):
"""
Read a comment from filename
@param: filename containing a comment
@type: string
@returns: a comment dict
"""
from xml.sax import make_parser, SAXException
from xml.sax.handler import feature_namespaces, ContentHandler
class cmtHandler(ContentHandler):
def __init__(self, cmt):
self._data = ""
self.cmt = cmt
def startElement(self, name, atts):
self._data = ""
def endElement(self, name):
self.cmt['cmt_'+name] = self._data
def characters(self, content):
self._data += content
cmt = {}
try:
story = open(filename)
parser = make_parser()
parser.setFeature(feature_namespaces, 0)
handler = cmtHandler(cmt)
parser.setContentHandler(handler)
parser.parse(story)
#story.close()
cmt['cmt_time'] = cmt['cmt_pubDate']
# timestamp as float for comment anchor
cmt['cmt_pubDate'] = time.ctime(float(cmt['cmt_pubDate']))
story.close()
except:
tools.log("Couldn't read: ", filename)
story.close()
return cmt
def writeComment(request, config, data, comment):
"""
Write a comment
@param config: dict containing pyblosxom config info
@type config: dict
@param data: dict containing entry info
@type data: dict
@param comment: dict containing comment info
@type comment: dict
@return: The success or failure of creating the comment.
@rtype: string
"""
entry = data['entry_list'][0]
cdir = os.path.join(config['comment_dir'], entry['absolute_path'])
cdir = os.path.normpath(cdir)
if not os.path.isdir(cdir):
os.makedirs(cdir)
cfn = os.path.join(
cdir, entry['fn'] + "-" + comment['pubDate'] + "." +
config['comment_draft_ext'])
argdict = {"request": request, "comment": comment}
reject = tools.run_callback("comment_reject",
argdict,
donefunc=lambda x: x)
if reject == 1:
return "Comment rejected."
# write comment
cfile = None
try:
cfile = open(cfn, "w")
except:
tools.log("Couldn't open comment file %s for writing" % cfn)
return "Error: Couldn't open comment file for writing."
else:
pass
def makeXMLField(name, field):
return "<" + name + ">" + cgi.escape(field[name]) + "</" + name + ">\n"
try:
try:
#TODO: fix this to 'utf-8' and commit to sf
comment[description].decode('utf-8')
cfile.write('<?xml version=1.0 encoding=utf-8?>\n')
except:
encoding = config.get('blog_encoding', 'iso-8859-1')
cfile.write('<?xml version="1.0" encoding="%s"?>\n' % encoding)
cfile.write("<item>\n")
cfile.write(makeXMLField('title', comment))
cfile.write(makeXMLField('author', comment))
cfile.write(makeXMLField('link', comment))
cfile.write(makeXMLField('source', comment))
cfile.write(makeXMLField('pubDate', comment))
cfile.write(makeXMLField('description', comment))
cfile.write("</item>\n")
cfile.close()
except:
tools.log("Error writing comment data for ", cfn)
cfile.close()
# write latest pickle
latest = None
latestFilename = os.path.join(config['comment_dir'], 'LATEST.cmt')
try:
latest = open(latestFilename, "w")
except:
tools.log("Couldn't open latest comment pickle for writing")
return "Error: Couldn't open latest comment pickle for writing."
else:
modTime = float(comment['pubDate'])
try:
cPickle.dump(modTime, latest)
latest.close()
except (IOError):
# should log or e-mail
if latest:
latest.close()
return "Error: Problem dumping the pickle."
# if the right config keys are set, notify by e-mail
if config.has_key('comment_smtp_server') and config.has_key(
'comment_smtp_to'):
# import the formatdate function which is in a different
# place in Python 2.3 and up.
try:
from email.Utils import formatdate
except ImportError:
from rfc822 import formatdate
import smtplib
author = escape_SMTP_commands(clean_author(comment['author']))
description = escape_SMTP_commands(comment['description'])
if comment.has_key('email'):
email = comment['email']
else:
email = config.get('comment_smtp_from', "*****@*****.**")
try:
server = smtplib.SMTP(config['comment_smtp_server'])
curl = config['base_url'] + '/' + entry['file_path']
headers = []
headers.append(("From", email))
headers.append(("To", config["comment_smtp_to"]))
headers.append(("Date", formatdate(modTime)))
headers.append(("Subject", "write back by %s" % author))
html = """%s<br />\n%s<br />\n<a href="%s">%s</a>\n""" % (
description, cfn, curl, curl)
message = createhtmlmail(html, headers)
server.sendmail(from_addr=email,
to_addrs=config['comment_smtp_to'],
msg=message)
server.quit()
except:
tools.log("Error sending mail: %s" % message)
return "Error: Problem sending notification email."
msg = "Success: Comment has been registered."
if config["comment_draft_ext"] != config["comment_ext"]:
msg = msg + " Comment will not appear until it has been manually approved by the owner of this web-site."
return msg
# Load up the cache (You can just import the base cache here)
cache_driver = tools.importName('Pyblosxom.cache', config.py.get('cacheDriver', 'base'))
cache = cache_driver.BlosxomCache(request, config.py.get('cacheConfig', ''))
try:
filename = os.path.join(config.py['datadir'], name)
entryData = {}
cache.load(filename)
# Look for cached documents
if cache.isCached():
entryData = cache.getEntry()
# Cached? Try our entryparsers then.
if not entryData:
fileExt = re.search(r'\.([\w]+)$', filename)
try:
entryData = blosxom_entry_parser(filename, request)
except IOError, e:
tools.log(e)
name = re.sub(config.py['datadir'],'',name)
parser = link(name, entryData['title'].strip(), entryData['body'].strip(), config.py['blog_title'])
trackback(parser)
pingback(parser)
except Exception, e:
tools.log(e)
if __name__ == '__main__':
for name in sys.argv[1:]:
autoping(name)
def writeComment(config, data, comment):
"""
Write a comment
@param config: dict containing pyblosxom config info
@type config: dict
@param data: dict containing entry info
@type data: dict
@param comment: dict containing comment info
@type comment: dict
"""
entry = data['entry_list'][0]
cdir = os.path.join(config['comment_dir'],entry['absolute_path'])
cdir = os.path.normpath(cdir)
if not os.path.isdir(cdir):
os.makedirs(cdir)
cfn = os.path.join(cdir,entry['fn']+"-"+comment['pubDate']+"."+config['comment_ext'])
# write comment
cfile = None
try :
cfile = open(cfn, "w")
except:
tools.log("Couldn't open comment file %s for writing" % cfn)
return
else:
pass
def makeXMLField(name, field):
return "<"+name+">"+cgi.escape(field[name])+"</"+name+">\n";
try:
cfile.write('<?xml version="1.0" encoding="iso-8859-1"?>\n')
cfile.write("<item>\n")
cfile.write(makeXMLField('title',comment))
cfile.write(makeXMLField('author',comment))
cfile.write(makeXMLField('link',comment))
cfile.write(makeXMLField('source',comment))
cfile.write(makeXMLField('pubDate',comment))
cfile.write(makeXMLField('description',comment))
cfile.write("</item>\n")
cfile.close()
except:
tools.log("Error writing comment data for ", cfn)
cfile.close()
#write latest pickle
latest = None
latestFilename = os.path.join(config['comment_dir'],'LATEST.cmt')
try:
latest = open(latestFilename,"w")
except:
tools.log("Couldn't open latest comment pickle for writing")
return
else:
modTime = float(comment['pubDate'])
try:
cPickle.dump(modTime,latest)
latest.close()
except (IOError):
# should log or e-mail
if latest:
latest.close()
return
# if the right config keys are set, notify by e-mail
if config.has_key('comment_smtp_server') and \
config.has_key('comment_smtp_to'):
import smtplib
author = escape_SMTP_commands(clean_author(comment['author']))
description = escape_SMTP_commands(comment['description'])
if comment.has_key('email'):
email = comment['email']
else:
email = config['comment_smtp_from']
try:
server = smtplib.SMTP(config['comment_smtp_server'])
curl = config['base_url']+'/'+entry['file_path']
message = []
message.append("From: %s" % email)
message.append("To: %s" % config["comment_smtp_to"])
message.append("Date: %s" % time.ctime(modTime))
message.append("Subject: write back by %s" % author)
message.append("")
message.append("%s\n%s\n%s\n" % (description, cfn, curl))
server.sendmail(from_addr=email,
to_addrs=config['comment_smtp_to'],
msg="\n".join(message))
server.quit()
except:
tools.log("Error sending mail: %s" % message)
pass
def cb_handle(args):
"""
@param args: a dict of plugin arguments
@type args: dict
"""
request = args['request']
pyhttp = request.getHttp()
config = request.getConfiguration()
urltrigger = config.get('trackback_urltrigger', '/trackback')
path_info = pyhttp['PATH_INFO']
if path_info.startswith(urltrigger):
print "Content-type: text/xml"
print
form = cgi.FieldStorage()
message = "not trackback"
if form.has_key("title") and form.has_key("excerpt") and \
form.has_key("url") and form.has_key("blog_name"):
import time
cdict = { 'title': form['title'].value, \
'author': 'Trackback from %s' % form['blog_name'].value, \
'pubDate' : str(time.time()), \
'link' : form['url'].value, \
'source' : form['blog_name'].value, \
'description' : form['excerpt'].value }
from Pyblosxom.entries.fileentry import FileEntry
from Pyblosxom.Request import Request
from Pyblosxom.pyblosxom import PyBlosxom
datadir = config['datadir']
from comments import writeComment
try:
import os
pi = path_info.replace(urltrigger, '')
path = os.path.join(datadir, pi[1:])
data = request.getData()
ext = tools.what_ext(data['extensions'].keys(), path)
entry = FileEntry(request, '%s.%s' % (path, ext), datadir)
data = {}
data['entry_list'] = [entry]
writeComment(config, data, cdict)
print tb_good_response
except OSError:
message = 'URI ' + path_info + " doesn't exist"
tools.log(message)
print tb_bad_response % message
else:
tools.log(message)
print tb_bad_response % message
import sys
sys.stdout.flush()
# no further handling is needed
return 1
else:
return 0
def cb_handle(args):
"""
@param args: a dict of plugin arguments
@type args: dict
"""
request = args['request']
pyhttp = request.getHttp()
config = request.getConfiguration()
urltrigger = config.get('trackback_urltrigger','/trackback')
path_info = pyhttp['PATH_INFO']
if path_info.startswith(urltrigger):
print "Content-type: text/xml"
print
form = cgi.FieldStorage()
message = "not trackback"
if form.has_key("title") and form.has_key("excerpt") and \
form.has_key("url") and form.has_key("blog_name"):
import time
cdict = { 'title': form['title'].value, \
'author': 'Trackback from %s' % form['blog_name'].value, \
'pubDate' : str(time.time()), \
'link' : form['url'].value, \
'source' : form['blog_name'].value, \
'description' : form['excerpt'].value }
from Pyblosxom.entries.fileentry import FileEntry
from Pyblosxom.Request import Request
from Pyblosxom.pyblosxom import PyBlosxom
datadir = config['datadir']
from comments import writeComment
try:
import os
pi = path_info.replace(urltrigger,'')
path = os.path.join(datadir, pi[1:])
data = request.getData()
ext = tools.what_ext(data['extensions'].keys(), path)
entry = FileEntry(request, '%s.%s' % (path, ext), datadir )
data = {}
data['entry_list'] = [ entry ]
writeComment(config, data, cdict)
print tb_good_response
except OSError:
message = 'URI '+path_info+" doesn't exist"
tools.log(message)
print tb_bad_response % message
else:
tools.log(message)
print tb_bad_response % message
import sys
sys.stdout.flush()
# no further handling is needed
return 1
else:
return 0
def writeComment(request, config, data, comment):
"""
Write a comment
@param config: dict containing pyblosxom config info
@type config: dict
@param data: dict containing entry info
@type data: dict
@param comment: dict containing comment info
@type comment: dict
@return: The success or failure of creating the comment.
@rtype: string
"""
entry = data['entry_list'][0]
cdir = os.path.join(config['comment_dir'], entry['absolute_path'])
cdir = os.path.normpath(cdir)
if not os.path.isdir(cdir):
os.makedirs(cdir)
cfn = os.path.join(cdir,entry['fn']+"-"+comment['pubDate']+"."+config['comment_draft_ext'])
argdict = { "request": request, "comment": comment }
reject = tools.run_callback("comment_reject",
argdict,
donefunc=lambda x:x)
if reject == 1:
return "Comment rejected."
# write comment
cfile = None
try :
cfile = open(cfn, "w")
except:
tools.log("Couldn't open comment file %s for writing" % cfn)
return "Error: Couldn't open comment file for writing."
else:
pass
def makeXMLField(name, field):
return "<"+name+">"+cgi.escape(field[name])+"</"+name+">\n";
try:
try:
#TODO: fix this to 'utf-8' and commit to sf
comment[description].decode('utf-8')
cfile.write('<?xml version=1.0 encoding=utf-8?>\n')
except:
encoding = config.get('blog_encoding', 'iso-8859-1')
cfile.write('<?xml version="1.0" encoding="%s"?>\n' % encoding)
cfile.write("<item>\n")
cfile.write(makeXMLField('title',comment))
cfile.write(makeXMLField('author',comment))
cfile.write(makeXMLField('link',comment))
cfile.write(makeXMLField('source',comment))
cfile.write(makeXMLField('pubDate',comment))
cfile.write(makeXMLField('description',comment))
cfile.write("</item>\n")
cfile.close()
except:
tools.log("Error writing comment data for ", cfn)
cfile.close()
# write latest pickle
latest = None
latestFilename = os.path.join(config['comment_dir'],'LATEST.cmt')
try:
latest = open(latestFilename,"w")
except:
tools.log("Couldn't open latest comment pickle for writing")
return "Error: Couldn't open latest comment pickle for writing."
else:
modTime = float(comment['pubDate'])
try:
cPickle.dump(modTime,latest)
latest.close()
except (IOError):
# should log or e-mail
if latest:
latest.close()
return "Error: Problem dumping the pickle."
# if the right config keys are set, notify by e-mail
if config.has_key('comment_smtp_server') and config.has_key('comment_smtp_to'):
# import the formatdate function which is in a different
# place in Python 2.3 and up.
try:
from email.Utils import formatdate
except ImportError:
from rfc822 import formatdate
import smtplib
author = escape_SMTP_commands(clean_author(comment['author']))
description = escape_SMTP_commands(comment['description'])
if comment.has_key('email'):
email = comment['email']
else:
email = config.get('comment_smtp_from', "*****@*****.**")
try:
server = smtplib.SMTP(config['comment_smtp_server'])
curl = config['base_url']+'/'+entry['file_path']
headers = []
headers.append(("From", email))
headers.append(("To", config["comment_smtp_to"]))
headers.append(("Date", formatdate(modTime)))
headers.append(("Subject", "write back by %s" % author))
html = """%s<br />\n%s<br />\n<a href="%s">%s</a>\n""" % (description, cfn, curl, curl)
message = createhtmlmail(html, headers)
server.sendmail(from_addr=email,
to_addrs=config['comment_smtp_to'],
msg=message)
server.quit()
except:
tools.log("Error sending mail: %s" % message)
return "Error: Problem sending notification email."
msg = "Success: Comment has been registered."
if config["comment_draft_ext"] != config["comment_ext"]:
msg = msg + " Comment will not appear until it has been manually approved by the owner of this web-site."
return msg
