def usage(args):
"""List this help"""
if args:
std_error_message('ERROR: ' + args + '\n')
for key in sorted(COMMANDS):
std_error_message('%10s: %s' % (key, COMMANDS[key].__doc__.strip()))
sys.exit(1)
def usage(args):
"""List this help"""
if args:
std_error_message('ERROR: ' + args + '\n')
for key in sorted(COMMANDS):
std_error_message('%10s: %s' % (key, COMMANDS[key].__doc__.strip()))
sys.exit(1)
def start_server(config):
"""
Start a simple webserver, from ``wsgiref``, to run our app.
"""
import sys
from wsgiref.simple_server import make_server, WSGIRequestHandler
class NoLogRequestHandler(WSGIRequestHandler):
def log_request(self, code='-', size='-'):
pass
hostname = config['server_host']['host']
port = int(config['server_host']['port'])
scheme = config['server_host']['scheme']
httpd = make_server(hostname, port, load_app(),
handler_class=NoLogRequestHandler)
LOGGER.debug('starting wsgi server at %s://%s:%s',
scheme, hostname, port)
std_error_message("starting wsgi server at %s://%s:%s"
% (scheme, hostname, port))
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
def usage(args):
"""List this help"""
if args:
std_error_message("ERROR: " + args + "\n")
for key in sorted(COMMANDS):
std_error_message("%10s: %s" % (key, COMMANDS[key].description))
sys.exit(1)
def usage(*args):
"""List this help"""
if args:
std_error_message('ERROR: ' + ' '.join(args) + '\n')
for key in sorted(COMMANDS):
std_error_message('%10s: %s' % (key, COMMANDS[key].description))
sys.exit(1)
def start_server(config):
"""
Start a simple webserver, from ``wsgiref``, to run our app.
"""
import sys
from wsgiref.simple_server import make_server, WSGIRequestHandler
class NoLogRequestHandler(WSGIRequestHandler):
def log_request(self, code='-', size='-'):
pass
hostname = config['server_host']['host']
port = int(config['server_host']['port'])
scheme = config['server_host']['scheme']
httpd = make_server(hostname,
port,
load_app(),
handler_class=NoLogRequestHandler)
LOGGER.debug('starting wsgi server at %s://%s:%s', scheme, hostname, port)
std_error_message("starting wsgi server at %s://%s:%s" %
(scheme, hostname, port))
try:
httpd.serve_forever()
except KeyboardInterrupt:
sys.exit(0)
def cache_tiddlers(package_name):
"""
Stores instance tiddlers in the package.
reads store_contents from <package>.instance
tiddler files are stored in <package>/resources/store
"""
instance_module = __import__('%s.instance' % package_name, None, None,
['instance'])
store_contents = instance_module.store_contents
target_store = Store('tiddlywebplugins.pkgstore',
{'package': package_name, 'read_only': False}, {})
sources = {}
for bag, uris in store_contents.items():
sources[bag] = []
for uri in uris:
if uri.endswith('.recipe'):
urls = recipe_to_urls(uri)
sources[bag].extend(urls)
else:
sources[bag].append(uri)
for bag_name, uris in sources.items():
bag = Bag(bag_name)
target_store.put(bag)
for uri in uris:
std_error_message('retrieving %s' % uri)
tiddler = url_to_tiddler(uri)
tiddler.bag = bag.name
target_store.put(tiddler)
def start_cherrypy():
"""
Start a cherrypy webserver to run our app.
"""
from cherrypy import wsgiserver
hostname = config['server_host']['host']
port = int(config['server_host']['port'])
app = load_app(prefix=config['server_prefix'])
server = wsgiserver.CherryPyWSGIServer((hostname, port), app)
try:
logging.debug('starting cherrypy at %s:%s', hostname, port)
std_error_message("Starting CherryPy at %s:%s" % (hostname, port))
server.start()
except KeyboardInterrupt:
server.stop()
def start_server(config):
from cheroot.wsgi import Server as WSGIServer
hostname = config['server_host']['host']
port = int(config['server_host']['port'])
scheme = config['server_host']['scheme']
app = load_app()
server = WSGIServer((hostname, port), app)
try:
LOGGER.debug('starting Cheroot at %s://%s:%s',
scheme, hostname, port)
std_error_message("Starting Cheroot at %s://%s:%s"
% (scheme, hostname, port))
server.start()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
def start_cherrypy(config):
"""
Start a cherrypy webserver to run our app.
"""
from cherrypy import wsgiserver
hostname = config['server_host']['host']
port = int(config['server_host']['port'])
scheme = config['server_host']['scheme']
app = load_app()
server = wsgiserver.CherryPyWSGIServer((hostname, port), app)
try:
logging.debug('starting cherrypy at %s://%s:%s', scheme, hostname,
port)
std_error_message("Starting CherryPy at %s://%s:%s" %
(scheme, hostname, port))
server.start()
except KeyboardInterrupt:
server.stop()
def assetcopy(args):
"""
Copy BFW's static assets into specified target directory
"""
from pkg_resources import resource_filename
if len(args) != 1:
std_error_message('ERROR: invalid target directory')
sys.exit(1)
target_dir = args[0]
assets_path = resource_filename('tiddlywebplugins.bfw', 'assets')
try:
shutil.copytree(assets_path, target_dir)
except OSError:
std_error_message('ERROR: target directory already exists - aborted')
sys.exit(2)
def start_cherrypy(config):
"""
Start a CherryPy webserver to run our app.
"""
from cherrypy.wsgiserver import CherryPyWSGIServer
hostname = config['server_host']['host']
port = int(config['server_host']['port'])
scheme = config['server_host']['scheme']
app = load_app()
server = CherryPyWSGIServer((hostname, port), app)
try:
LOGGER.debug('starting CherryPy at %s://%s:%s',
scheme, hostname, port)
std_error_message("Starting CherryPy at %s://%s:%s"
% (scheme, hostname, port))
server.start()
except KeyboardInterrupt:
server.stop()
def deltiddler(args):
"""Delete a tiddler from a bag: <bag> <title>"""
from tiddlyweb.model.tiddler import Tiddler
from tiddlyweb.store import NoTiddlerError
from tiddlyweb.util import std_error_message
bag, title = args
prompt = 'deleting tiddler %s from bag %s - enter "yes" to confirm' % (
title, bag)
if raw_input('%s\n' % prompt) == 'yes':
store = get_store(config)
tiddler = Tiddler(title, bag)
try:
store.delete(tiddler)
except NoTiddlerError:
std_error_message('error deleting tiddler %s from bag %s: %s' %
(title, bag, 'no such tiddler'))
return True
else:
std_error_message('aborted')
return False
def deltiddler(args):
"""Delete a tiddler from a bag: <bag> <title>"""
from tiddlyweb.model.tiddler import Tiddler
from tiddlyweb.store import NoTiddlerError
from tiddlyweb.util import std_error_message
bag, title = args
prompt = 'deleting tiddler %s from bag %s - enter "yes" to confirm' % (
title, bag)
if raw_input('%s\n' % prompt) == 'yes':
store = get_store(config)
tiddler = Tiddler(title, bag)
try:
store.delete(tiddler)
except NoTiddlerError:
std_error_message(
'error deleting tiddler %s from bag %s: %s' % (
title, bag, 'no such tiddler'))
return True
else:
std_error_message('aborted')
return False
def cache_tiddlers(package_name):
"""
creates local cache of instance tiddlers to be included in distribution
reads store_contents from <package>.instance
tiddler files are stored in <package>/resources/<bag>
a complete index is stored in <package>/resources
"""
instance_module = __import__("%s.instance" % package_name, None, None,
["instance"]) # XXX: unnecessarily convoluted and constraining!?
store_contents = instance_module.store_contents
package_path = os.path.join(*package_name.split("."))
sources = {}
for bag, uris in store_contents.items():
sources[bag] = []
for uri in uris:
if uri.endswith(".recipe"):
urls = recipe_to_urls(uri)
sources[bag].extend(urls)
else:
sources[bag].append(uri)
metas = []
for uri in sources[bag]:
metas.append("%s.meta" % uri)
sources[bag].extend(metas)
resources_path = os.path.join(package_path, "resources")
try:
os.mkdir(resources_path)
except OSError: # directory exists
pass
for bag, uris in sources.items():
bag_path = os.path.join(resources_path, bag)
try:
os.mkdir(bag_path)
except OSError: # directory exists
pass
for uri in uris:
filepath = os.path.join(bag_path, os.path.basename(uri))
std_error_message("retrieving %s" % uri)
try: # XXX: duplication of tiddlywebplugins.twimport._get_url_handle
try:
content = urlopen(uri).read()
except (URLError, OSError):
scheme, netloc, path, params, query, fragment = urlparse.urlparse(uri)
path = quote(path)
uri = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
content = urlopen(uri).read()
try:
content = unicode(content, "utf-8")
write_utf8_file(filepath, content)
except UnicodeDecodeError: # assume binary
f = open(filepath, "wb")
f.write(content)
f.close()
except (URLError, OSError):
if uri.endswith(".meta"):
std_error_message("no meta file found for %s" % uri[:-5])
else:
raise
tiddler_index = "tiddlers.index"
tiddler_paths = []
for base_dir, dirs, files in os.walk(resources_path):
bag = os.path.basename(base_dir)
if bag in store_contents:
filepaths = (os.path.join(bag, filename) for filename in files
if not filename.endswith(".meta") and not filename == tiddler_index)
tiddler_paths.extend(filepaths)
filepath = "/".join([resources_path, tiddler_index])
std_error_message("creating %s" % filepath)
write_utf8_file(filepath, "\n".join(tiddler_paths))
