def show(tag):
'''
Renders a page containing those entries defined by tag. If tag is None,
will yield all entries.
'''
page_num = int(request.args.get('page', 0))
per_page = mainApp.config['NUM_ENTRIES_PER_PAGE'][0]
entryDB = EntryDB()
if tag:
entries = entryDB.find_by_tags([tag])
static_entries = None
count = per_page
else:
entries = entryDB.find_recent_by_num(per_page, page_num * per_page)
static_entries = None
if page_num == 0:
static_entries = entryDB.find_static()
count = entryDB.count()
total_pages = 0
if count > per_page:
total_pages = int(ceil(float(count) / float(per_page)))
return render_template('list_entries.html', entries=entries,
state=get_state(), page_num=page_num, total_pages=total_pages,
static_entries=static_entries)
class Icebox:
__borg_state = {}
def __init__(self):
self.__dict__ = self.__borg_state
try:
self._setup
except AttributeError:
self._setup = False
if not self._setup:
self.event_log = EventLog()
self.entry_db = EntryDB()
self.icebox_path = abspath(mainApp.config['ICEBOX_PATH'])
if mainApp.config['ICEBOX_STATIC_PATH'] is not None:
self.static_path = abspath(mainApp.config['ICEBOX_STATIC_PATH'])
else:
self.static_path = None
self.client = mainApp.test_client()
self._setup = True
def generate_pages(self, all_pages=False):
"""
Generate the pages.
If all_pages is True, will regenerate the entire site.
"""
if not isdir(self.icebox_path):
makedirs(self.icebox_path)
state = State()
state.icebox = True
if all_pages:
self._rebuild_site()
else:
for e in self.event_log.get_unprocessed():
if e.event in ('add_entry', 'update_entry'):
pe = depickle(e.blob)
entry = self.entry_db.find_by_id(pe.id)
if entry is not None:
self._generate_page(entry)
elif e.event == 'rebuild_static':
self._rebuild_site()
elif e.event == 'del_entry':
pe = depickle(e.blob)
self._remove_page(pe.id, pe.url)
self.event_log.mark_as_processed(e)
# Regenerate index
self._generate_index()
# Regenerate tags
self._generate_tags()
# Sync static pages
if self.static_path:
self.sync_static()
def _rebuild_site(self):
"""
Rebuild the entire site
"""
self.clear_icebox_path()
count = self.entry_db.count()
per_page = mainApp.config['NUM_ENTRIES_PER_PAGE'][0]
total_pages = int(ceil(float(count) / float(per_page)))
for i in range(total_pages):
entries = self.entry_db.find_recent_by_num(per_page,
i * per_page)
for e in entries:
self._generate_page(e)
def _generate_tags(self):
"""
Generate the tag pages.
"""
# Clean up old tags
rmfiles = glob('{0}/tag/*'.format(self.icebox_path))
for f in rmfiles:
if isfile(f):
remove(f)
all_tags = self.entry_db.get_tags()
for t in all_tags:
response = self.client.get("/tag/{0}".format(t.id),
follow_redirects=True)
html = response.data
filename = 'tag/{0}.html'.format(t.id)
self._write_page(html, filename)
def sync_static(self):
"""
Synchronize static content
"""
base_dir = "{0}/s".format(self.icebox_path)
if not isdir(base_dir):
makedirs(base_dir)
for root, dummy, files in walk(join(self.icebox_path, 's')):
for f in files:
if isfile(join(root, f)):
remove(join(root, f))
for root, dummy, files in walk(self.static_path):
for f in files:
source_name = join(root, f)
dest_name = join(join(
'{0}/s'.format(self.icebox_path),
relpath(root, self.static_path)), f)
base_dest = dirname(dest_name)
if not isdir(base_dest):
makedirs(base_dest)
link(source_name, dest_name)
def clear_icebox_path(self):
"""
Will clear the icebox path.
WARNING: This is destructive, and should only be used when you know
what you're doing. This will nuke the contents of the icebox path.
"""
rmfiles = []
for root, dirs, files in walk(self.icebox_path):
for d in dirs:
rmfiles.append(join(root, d))
for f in files:
rmfiles.append(join(root, f))
rmfiles.sort(key=len)
rmfiles.reverse()
for f in rmfiles:
if isfile(f):
remove(f)
elif isdir(f):
rmdir(f)
def _convert_url_to_path(self, url):
"""
Given a URL, convert it to a filepath.
Return filepath.
"""
if url.endswith('/'):
url += 'index.html'
else:
url += '.html'
if url.startswith('/'):
return url[1:]
else:
return url
def _generate_page(self, entry):
"""
Given an entry, will generate the page for it (including any
aliases).
"""
response = self.client.get('/node/{0}'.format(entry.id),
follow_redirects=True)
html = response.data
# First, generate the node
filename = 'node/{0}.html'.format(entry.id)
self._write_page(html, filename)
if entry.url:
filename = self._convert_url_to_path(entry.url)
self._write_page(html, filename)
def _generate_index(self):
"""
Generate the main index
"""
# First clear the old indexes out of the way
rmfiles = ['{0}/index.html'.format(self.icebox_path)]
rmfiles.extend(glob('{0}/index_page_*'.format(self.icebox_path)))
for f in rmfiles:
if isfile(f):
remove(f)
per_page = mainApp.config['NUM_ENTRIES_PER_PAGE'][0]
count = self.entry_db.count()
total_pages = 0
if count > per_page:
total_pages = int(ceil(float(count) / float(per_page)))
response = self.client.get('/', follow_redirects=True)
html = response.data
filename = 'index.html'
self._write_page(html, filename)
for i in range(total_pages):
response = self.client.get('/?page={0}'.format(i),
follow_redirects=True)
html = response.data
filename = 'index_page_{0}.html'.format(i)
self._write_page(html, filename)
def _write_page(self, html, filename):
"""
Write the actual page to filename
"""
fullname = "{0}/{1}".format(self.icebox_path, filename)
base_dir = dirname(fullname)
if not isdir(base_dir):
makedirs(base_dir)
with open(fullname, 'wb') as fd:
fd.write(html)
def _remove_page(self, entry_id, entry_url):
"""
Given an entry, will remove the page for it.
"""
node_fn = 'node/{0}.html'.format(entry_id)
if isfile(node_fn):
remove(node_fn)
if entry_url:
filename = self._convert_url_to_path(entry_url)
if isfile(filename):
remove(filename)