def remove(self, resource_name):
""" Remove a resource by path/name """
if self.is_readonly:
raise zExceptions.Forbidden(_('Connector is readonly'))
subpath = safe_unicode(self.request.get('subpath', self.subpath))
handle = self.context.get_handle()
if not handle.exists(resource_name):
msg = 'Not found {}'.format(resource_name)
raise zExceptions.NotFound(msg)
if handle.isdir(resource_name):
try:
handle.removetree(resource_name)
except Exception as e:
msg = resource_name + _(' could not be deleted') + ' ({})'.format(e)
self.request.response.setStatus(500)
return msg
elif handle.isfile(resource_name):
try:
handle.remove(resource_name)
except Exception as e:
msg = _('{} could not be deleted ({})').format(resource_name, e)
self.request.response.setStatus(500)
return msg
else:
msg = _('Unhandled file type for {}').format(resource_name)
raise RuntimeError(msg)
msg = _('Deleted {}').format(resource_name)
self.request.response.setStatus(200)
def __call__(self):
""" Download given file """
handle = self.context.get_handle()
filename = self.subpath
if not handle.exists(filename):
raise zExceptions.NotFound('{} does not exist'.format(filename))
basename = os.path.basename(filename)
basename, ext = os.path.splitext(basename)
mt, encoding = mimetypes.guess_type(filename)
self.request.response.setHeader('content-type', mt)
if 'download' in self.request.form or 'filename' in self.request.form:
fn = self.request.get('filename', os.path.basename(filename))
self.request.response.setHeader(
'content-disposition', 'attachment; filename="{}"'.format(fn))
content_length = handle.getsize(filename)
if content_length:
self.request.response.setHeader('content-length',
str(content_length))
return connector_iterator(handle, filename)
else:
with handle.open(filename, 'rb') as fp:
data = fp.read()
self.request.response.setHeader('content-length',
str(len(data)))
return data
def __call__(self, *args, **kw):
qs = self.request.QUERY_STRING
user = getSecurityManager().getUser()
# request/force_default_view can be used to force a redirect to the
# default anonymous view
force_default_view = self.request.form.get('force_default_view', 0)
if force_default_view:
if user.has_permission(permissions.View, self.context):
default_view = self.context.default_view_anonymous
if qs:
default_view += '?' + qs
return self.request.response.redirect('{}/{}'.format(
self.context.absolute_url(), default_view))
else:
LOG.error(
u'Unable to redirect to anonymous default view of ({}, {})'
.format(user.getUserName(), self.context.absolute_url(1)))
raise zExceptions.NotFound()
if user.has_permission(permissions.ModifyPortalContent, self.context):
default_view = self.context.default_view_authenticated
if qs:
default_view += '?' + qs
return self.request.response.redirect('{}/{}'.format(
self.context.absolute_url(), default_view))
else:
default_view = self.context.default_view_anonymous
if default_view:
if qs:
default_view += '?' + qs
return self.request.response.redirect('{}/{}'.format(
self.context.absolute_url(), default_view))
else:
msg = _(u'No default view configured for anonymous visitors')
self.context.plone_utils.addPortalMessage(msg, 'error')
raise zExceptions.NotFound()
def __call__(self, *args, **kw):
user = getSecurityManager().getUser()
if user.has_permission(permissions.ModifyPortalContent, self.context):
default_view = self.context.default_view_authenticated
return self.request.response.redirect(
'{}/{}'.format(self.context.absolute_url(), default_view))
else:
default_view = self.context.default_view_anonymous
if default_view:
return self.request.response.redirect(
'{}/{}'.format(self.context.absolute_url(), default_view))
else:
msg = _(u'No default view configured for anonymous visitors')
self.context.plone_utils.addPortalMessage(msg, 'error')
raise zExceptions.NotFound()
def __bobo_traverse__(self, request, entryname):
""" Traversal hook for (un)restrictedTraverse() """
self.traversal_subpath.append(entryname)
traversal_subpath = '/'.join(self.traversal_subpath)
handle = self.webdav_handle()
if handle.exists(traversal_subpath):
if handle.isdir(traversal_subpath):
return self
elif handle.isfile(traversal_subpath):
data = handle.open(traversal_subpath, 'rb').read()
self.wrapped_object = data
self.wrapped_info = handle.getinfo(traversal_subpath)
try:
self.wrapped_meta = handle.getmeta(traversal_subpath)
except fs.errors.NoMetaError:
self.wrapped_meta = None
return self
raise zExceptions.NotFound('not found: {}'.format(entryname))
def content(self, path=None):
if not path:
path = self.path
app_id = path[0]
app = get_app(app_id, self.request)
method = getattr(IDisplay(app), self.method)
try:
(result, redirect) = method(path, self.request)
except NotAllowed:
raise zExceptions.BadRequest()
except NotFound:
raise zExceptions.NotFound()
except Unauthorized:
raise unauth("Not authorized")
self.store_app_messages(app)
if redirect:
self.request.RESPONSE.redirect(redirect)
else:
return result
def remote_exists(self, path):
""" Check if `path` exists based on our own traversal.
The purpose of this method is to provide a traversal
lookup that is not dependent on Acquisition but on
real traversal.
E.g. a request to `/plone/papers/conference/papers` would
resolve to the first `papers` folder if the second
`papers` folder does not exist.
"""
# current = self.context.restrictedTraverse("/")
current = plone.api.portal.get()
for c in path.split("/"):
if not c:
continue
if c in current.objectIds():
current = current[c]
else:
raise zExceptions.NotFound(path)
self.request.response.setStatus(200)
def get_handle(self, subpath=None, root=False):
""" Returns a webdav handle for the current subpath """
if not root:
if not subpath:
subpath = '/'.join(self.subpath)
try:
return self.context.get_handle(subpath)
except fs.errors.ResourceNotFoundError as e:
msg = 'eXist-db path {} does not exist'.format(e.url)
self.context.plone_utils.addPortalMessage(msg, 'error')
LOG.debug(msg)
raise zExceptions.NotFound()
except fs.errors.PermissionDeniedError as e:
msg = 'eXist-db path {} unauthorized access (check credentials)'.format(
e.url)
self.context.plone_utils.addPortalMessage(msg, 'error')
LOG.error(msg)
raise zExceptions.Unauthorized()
def _render(self):
name = self.request.form.get('name')
if not name:
raise ValueError('Parameter "name" is missing')
mt, encoding = mimetypes.guess_type(os.path.basename(name))
handle = self.context.get_handle(create_if_not_existing=True)
if handle.exists(name):
fp = handle.open(name, 'rb')
size = handle.getsize(name)
self.request.response.setHeader('content-length', str(size))
self.request.response.setHeader('content-type', mt)
self.request.response.setHeader(
'content-disposition',
'attachment; filename={}'.format(os.path.basename(name)))
return fs_filestream_iterator(fp)
else:
self.request.response.setStatus(403)
raise zExceptions.NotFound(u'Not found: {}'.format(name))
def __bobo_traverse__(self, request, entryname):
""" Traversal hook for (un)restrictedTraverse() """
self.traversal_subpath.append(entryname)
traversal_subpath = '/'.join(self.traversal_subpath)
handle = self.get_handle()
if six.PY2:
traversal_subpath = unicode(traversal_subpath, 'utf8')
if handle.exists(traversal_subpath):
if handle.isdir(traversal_subpath):
return self
elif handle.isfile(traversal_subpath):
with handle.open(traversal_subpath, 'rb') as fp:
data = fp.read()
self.wrapped_object = data
self.wrapped_info = handle.getinfo(traversal_subpath, namespaces=['access', 'details'])
try:
self.wrapped_meta = handle.getmeta(traversal_subpath)
except fs.errors.NoMetaError:
self.wrapped_meta = None
return self
raise zExceptions.NotFound('not found: {}'.format(entryname))
def get_handle(self, subpath=None, create_if_not_existing=False):
""" Return WebDAV handle to root of configured connector object
including configured connector_subpath.
"""
registry = getUtility(IRegistry)
settings = registry.forInterface(IConnectorSettings)
adapted = IConnector(self)
url = adapted.connector_url or settings.connector_url
if adapted.connector_subpath:
url += '/{}'.format(adapted.connector_subpath)
if subpath:
url += '/{}'.format(urllib.quote(subpath))
# system-wide credentials
username = settings.connector_username
password = settings.connector_password or ''
# local credentials override the system credentials
if adapted.connector_url:
username = adapted.connector_username or ''
password = adapted.connector_password or ''
if create_if_not_existing:
util = getUtility(IConnectorHandle)
handle = util.get_handle()
if not handle.exists(adapted.connector_subpath):
handle.makedir(adapted.connector_subpath, recursive=True)
url = '{}/{}'.format(handle.url.strip('/'),
adapted.connector_subpath)
try:
return get_fs_wrapper(url, credentials=dict(username=username, password=password), context=self)
except fs.errors.ResourceNotFoundError:
LOG.warn(u'Error accessing {}::{}::{}'.format(
self.absolute_url(), url, self.REQUEST.get('HTTP_USER_AGENT')), exc_info=True)
raise zExceptions.NotFound(url)
except fs.errors.ResourceInvalidError:
parts = url.rsplit('/', 1)
wrapper = get_fs_wrapper(parts[0], credentials=dict(
username=username, password=password),
context=self)
wrapper.__leaf__ = True
wrapper.__leaf_filename__ = parts[1]
return wrapper
except fs.errors.RemoteConnectionError as e:
# LOG.error(u'Error accessing {}::{}::{}'.format(
# self.absolute_url(),
# url,
# self.REQUEST.get('HTTP_USER_AGENT')),
# exc_info=True)
exc = RuntimeError(url)
exc.url = url
raise exc
except Exception as e:
print repr(e)
LOG.warn(u'Error accessing {}::{}::{}'.format(
self.absolute_url(), url, self.REQUEST.get('HTTP_USER_AGENT')), exc_info=True)
e.url = url
raise e
