def __init__(self, cms):
self.__cms = cms
self.__dispatcher = Dispatcher()
# Set the default location for file-based sessions
sconf = session.config
using_file_sessions = (sconf.get("session.type") == "file")
using_dbm_sessions = (sconf.get("session.type") == "dbm")
lock_dir_missing = (not using_file_sessions
and not sconf.get("session.lock_dir"))
data_dir_missing = (
(using_file_sessions or
(using_dbm_sessions and not sconf.get("session.dbm_dir")))
and not sconf.get("session.data_dir"))
if lock_dir_missing or data_dir_missing:
session_path = app.path("sessions")
if not os.path.exists(session_path):
os.mkdir(session_path)
if lock_dir_missing:
sconf["session.lock_dir"] = session_path
if data_dir_missing:
sconf["session.data_dir"] = session_path
if not sconf.get("session.secret"):
session_key_path = app.path(".session_key")
if os.path.exists(session_key_path):
with open(session_key_path, "r") as session_key_file:
session_key = session_key_file.readline()
else:
with open(session_key_path, "w") as session_key_file:
session_key = sha("".join(
choice(ascii_letters)
for i in range(10))).hexdigest()
session_key_file.write(session_key)
sconf["session.secret"] = session_key
# Create the folders for uploaded files
upload_path = app.path("upload")
if not os.path.exists(upload_path):
os.mkdir(upload_path)
temp_path = app.path("upload", "temp")
if not os.path.exists(temp_path):
os.mkdir(temp_path)
async_uploader.temp_folder = temp_path
def setup_package():
if not get_selenium_enabled():
return
# Create a temporary folder to hold site files
_site_temp_path = mkdtemp()
app.root = _site_temp_path
# Set up a temporary database
datastore.storage = FileStorage(app.path("testdb.fs"))
# Initialize site content before testing
site_initializer = SiteInitializer()
site_initializer.initialize(admin_email, admin_password, site_languages)
datastore.commit()
# Configure the site's webserver
hostname, port = get_selenium_site_address()
cherrypy.config.update({
"log.screen": False,
"server.socket_host": hostname,
"server.socket_port": port,
"engine.autoreload.on": False
})
# Configure the application
cms = CMSController()
cms.closing_item_requires_confirmation = False
# Launch the site's webserver on another thread
cms.run(block=False)
def request_encoding(file, encoder):
if isinstance(encoder, basestring):
encoder = AudioEncoder.require_instance(identifier=encoder)
dest = get_audio_cache_dest(file, encoder)
# The file hasn't been generated yet
if not os.path.exists(dest):
request = None
request_key = (file.id, encoder.identifier)
with _cache_lock:
request = _cache_ongoing_requests.get(request_key)
# Another thread is already requesting this file encoding: wait
# for it to finish
if request is not None:
new_request = False
# No other thread is generating the requested file/encoding
# combination at present: generate it
else:
request = Event()
_cache_ongoing_requests[request_key] = request
new_request = True
# Make sure the cache folder for the indicated file exists
folder = app.path("audio-cache", str(file.id))
if not os.path.exists(folder):
os.mkdir(folder)
if new_request:
try:
encoder.encode(file, dest)
with _cache_lock:
_create_symlink(file, dest)
request.set()
finally:
try:
del _cache_ongoing_requests[request_key]
except KeyError:
pass
else:
request.wait()
return dest
def _export(self, context, status_tracker=None):
StaticSiteDestination._export(self,
context,
status_tracker=status_tracker)
# Close the zip file before export it to the CMS
context["zip_file"].close()
upload_path = app.path("upload")
with changeset_context(get_current_user()):
file = File.from_path(context["temp_file"],
upload_path,
languages=[get_language()])
file.title = "export-%s" % date.today().strftime("%Y%m%d")
file.file_name = file.title + ".zip"
file.insert()
context.update(file=file)
def _create_symlink(file, dest):
"""Create a symbolic link for static publication of an encoded file."""
if not hasattr(os, "symlink"):
return
# Only create static publication links for public content
anonymous = User.require_instance(qname="woost.anonymous_user")
if not anonymous.has_permission(ReadPermission, target=file):
return
static_folder = app.path("static", "audio", str(file.id))
static_link = os.path.join(static_folder, os.path.basename(dest))
if not os.path.lexists(static_link):
# Make sure the containing folder exists
if not os.path.exists(static_folder):
os.mkdir(static_folder)
os.symlink(dest, static_link)
def clear_image_cache(item=None, factory=None):
if not app.root:
return
if debug:
from cocktail.styled import styled
print styled("Clearing image cache", "red"),
if item:
print styled("Item:", "light_gray"),
print styled(item, "red", style="bold"),
if factory:
print styled("Factory:", "light_gray"),
print styled(factory, "red", style="bold"),
print
# Remove the full cache
if item is None and factory is None:
_remove_dir_contents(app.path("image-cache"))
_remove_dir_contents(app.path("static", "images"))
# Selective drop: per item and/or factory
else:
paths = []
if item is not None:
paths.append(app.path("image-cache", str(item.id)))
paths.append(app.path("static", "images", str(item.id)))
else:
for base in (app.path("image-cache"), app.path("static",
"images")):
for item in os.listdir(base):
path = os.path.join(base, item)
if os.path.isdir(path):
paths.append(path)
if factory is None:
pattern = None
else:
pattern = factory + ".*"
for path in paths:
_remove_dir_contents(path, pattern)
def submit(self):
self.imported_files = []
file = self.form_data["upload"]["file"]
zip_file = ZipFile(file)
upload_path = app.path("upload")
temp_dir = mkdtemp()
try:
with changeset_context(get_current_user()):
for file_path in zip_file.namelist():
file_name = os.path.basename(file_path)
# Skip directories
if not file_name:
continue
source = zip_file.open(file_path)
temp_file = os.path.join(temp_dir, file_name)
dest = open(temp_file, "wb")
copyfileobj(source, dest)
source.close()
dest.close()
try:
imported_file = File.from_path(temp_file, upload_path)
imported_file.insert()
self.imported_files.append(imported_file)
finally:
os.remove(temp_file)
datastore.commit()
finally:
os.rmdir(temp_dir)
def clear_audio_cache(item=None, encoder_id=None):
if debug:
from cocktail.styled import styled
print styled("Clearing audio cache", "red"),
if item:
print styled("Item:", "light_gray"),
print styled(item, "red", style="bold"),
if encoder_id:
print styled("Encoder:", "light_gray"),
print styled(encoder_id, "red", style="bold"),
print
# Remove the full cache
if item is None and encoder_id is None:
_remove_dir_contents(app.path("audio-cache"))
_remove_dir_contents(app.path("static", "audio"))
# Selective drop: per item and/or encoder
else:
paths = []
if item is not None:
paths.append(app.path("audio-cache", str(item.id)))
paths.append(app.path("static", "audio", str(item.id)))
else:
for base in (app.path("audio-cache"), app.path("static", "audio")):
for item in os.listdir(base):
path = os.path.join(base, item)
if os.path.isdir(path):
paths.append(path)
if encoder_id is None:
pattern = None
else:
pattern = encoder_id + ".*"
for path in paths:
_remove_dir_contents(path, pattern)
def get_audio_cache_dest(file, encoder):
return app.path("audio-cache", str(file.id),
encoder.identifier + encoder.extension)
def file_path(self):
return app.path("upload", str(self.id))
def get_client():
credentials = ServiceAccountCredentials.from_json_keyfile_name(
app.path("ga-client-secrets.json"), SCOPES)
return build("analyticsreporting", "v4", credentials=credentials)
def snapshot_path(self):
return app.path("snapshots", str(self.id))
def execute_in_subprocess(self):
script = app.path("scripts", "staticpub.py")
return subprocess.Popen([
os.path.join(sys.prefix, "bin", "python"), script, "export",
f"export:{self.id}"
])
def temp_file_path(self):
return app.path(
"upload", "temp",
"%s-%s-%s" % (self.item.id, session.id, self.stack.to_param()))
def require_rendering(item, factory=None, format=None, parameters=None):
ext = None
if factory is None:
factory = ImageFactory.require_instance(identifier="default")
if format is None:
if not isinstance(item, type):
ext = getattr(item, "file_extension", None)
if ext is not None:
format = formats_by_extension.get(ext.lstrip(".").lower())
if format is None:
ext = None
elif format not in mime_types_by_format:
raise BadRenderingRequest("Invalid image format: %s" % format)
if format is None:
format = default_format
if ext is None:
ext = extensions_by_format[format]
identifier = factory.identifier or "factory%d" % factory.id
file_name = "%s.%s" % (identifier, ext)
item_id = item.full_name if isinstance(item, type) else str(item.id)
# If the image hasn't been generated yet, do so and store it in the
# application's image cache
image_cache_file = app.path("image-cache", item_id, file_name)
if not os.path.exists(image_cache_file):
# Generate the file
image = factory.render(item)
if not image:
raise RenderError("Can't render %s" % item)
# Store the generated image in the image cache
try:
os.mkdir(app.path("image-cache", item_id))
except OSError:
pass
if isinstance(image, basestring):
try:
os.remove(image_cache_file)
except OSError:
pass
if hasattr(os, "symlink"):
os.symlink(image, image_cache_file)
else:
copy(image, image_cache_file)
else:
if format == 'JPEG' and image.mode not in ('RGB', 'RGBA'):
image = image.convert('RGBA')
elif format == 'PNG' and image.mode == "CMYK":
image = image.convert('RGBA')
image.save(image_cache_file, format)
# If the image is accessible to anonymous users, create a link in the
# application's static content folder (further requests will be served
# by the web server, no questions asked).
if hasattr(os, "symlink"):
static_publication_link = \
app.path("static", "images", item_id, file_name)
if not os.path.lexists(static_publication_link):
anonymous = User.require_instance(qname="woost.anonymous_user")
if anonymous.has_permission(RenderPermission,
target=item,
image_factory=factory):
try:
os.mkdir(app.path("static", "images", item_id))
except OSError:
pass
os.symlink(image_cache_file, static_publication_link)
return image_cache_file
def create_export_script():
script_path = app.path("scripts", "staticpub.py")
with open(script_path, "w") as script_file:
script_file.write(EXPORT_SCRIPT_TEMPLATE % {"package": app.package})
def get_links(file):
return [
app.path("static", app.url_resolver.get_path(file, language))
for language in (file.translations or [None])
]
def create_exporter(self) -> Exporter:
folder = self.zip_folder or app.path("x-staticpub-zip-files")
os.makedirs(folder, exist_ok=True)
filename = os.path.join(folder, f"{self.export.id}.zip")
self.export.zip_path = filename
return super().create_exporter(filename=filename)
