def home(req):
main = fs.FileSystemStorage()
dirs, files = main.listdir("")
des = []
for file in files:
des.append(Desc(file, str(file).replace(".", "_dot_")))
return render(req, 'camtest.html', {'data': des})
def get_photos(username):
photos = []
fs = storage.FileSystemStorage(location=settings.MEDIA_ROOT)
for short_code, url in _get_photo_list(username):
if not fs.exists(short_code):
response = requests.get(url)
if not response.ok:
LOGGER.error('Error fetching image: %r', response.status_code)
continue
fs.save(short_code, io.BytesIO(response.content))
photos.append(fs.url(short_code))
return photos
def update(self, uploaded_file):
"""uploaded_file is an instance of
django UploadedFile object
"""
#1) come up with a file name
file_storage = storage.FileSystemStorage(
location=self.upload_directory, base_url=self.upload_url)
#todo: need better function here to calc name
file_name = file_storage.get_available_name(uploaded_file.name)
file_storage.save(file_name, uploaded_file)
url = file_storage.url(file_name)
old_file = self.value
old_file = old_file.replace(self.upload_url, '', 1)
old_file_path = os.path.join(self.upload_directory, old_file)
if os.path.isfile(old_file_path):
os.unlink(old_file_path)
#saved file path is relative to the upload_directory
#so that things could be easily relocated
super(ImageValue, self).update(url)
class ImportPackageWizard(views.ModalFormMixin,
wizard_views.SessionWizardView):
file_storage = storage.FileSystemStorage(location=consts.CACHE_DIR)
template_name = 'packages/upload.html'
condition_dict = {'add_category': is_app}
def get_context_data(self, **kwargs):
context = super(ImportPackageWizard, self).get_context_data(**kwargs)
context['murano_repo_url'] = packages_consts.MURANO_REPO_URL
return context
def done(self, form_list, **kwargs):
data = self.get_all_cleaned_data()
app_id = self.storage.get_step_data('upload')['package'].id
# Remove package file from result data
for key in ('package', 'import_type', 'url', 'repo_version',
'repo_name'):
del data[key]
dep_pkgs = self.storage.get_step_data('upload').get('dependencies', [])
redirect = reverse('horizon:murano:packages:index')
dep_data = {'enabled': data['enabled'], 'is_public': data['is_public']}
murano_client = api.muranoclient(self.request)
for dep_pkg in dep_pkgs:
try:
murano_client.packages.update(dep_pkg.id, dep_data)
except Exception as e:
msg = _("Couldn't update package {0} parameters. Error: {1}")\
.format(dep_pkg.fully_qualified_name, e)
LOG.warning(msg)
messages.warning(self.request, msg)
try:
data['tags'] = [t.strip() for t in data['tags'].split(',')]
murano_client.packages.update(app_id, data)
except exc.HTTPForbidden:
msg = _("You are not allowed to change"
" this properties of the package")
LOG.exception(msg)
exceptions.handle(
self.request,
msg,
redirect=reverse('horizon:murano:packages:index'))
except (exc.HTTPException, Exception):
LOG.exception(_('Modifying package failed'))
exceptions.handle(self.request,
_('Unable to modify package'),
redirect=redirect)
else:
msg = _('Package parameters successfully updated.')
LOG.info(msg)
messages.success(self.request, msg)
return http.HttpResponseRedirect(redirect)
def _handle_exception(self, original_e):
exc_info = sys.exc_info()
reason = ''
if hasattr(original_e, 'details'):
try:
error = json.loads(original_e.details).get('error')
if error:
reason = error.get('message')
except ValueError:
# Let horizon operate with original exception
raise exc_info[0], exc_info[1], exc_info[2]
msg = _('Uploading package failed. {0}').format(reason)
LOG.exception(msg)
exceptions.handle(self.request,
msg,
redirect=reverse('horizon:murano:packages:index'))
def process_step(self, form):
@catalog_views.update_latest_apps
def _update_latest_apps(request, app_id):
LOG.info('Adding {0} application to the'
' latest apps list'.format(app_id))
step_data = self.get_form_step_data(form)
if self.steps.current == 'upload':
import_type = form.cleaned_data['import_type']
data = {}
f = None
base_url = packages_consts.MURANO_REPO_URL
if import_type == 'upload':
pkg = form.cleaned_data['package']
f = pkg.file
elif import_type == 'by_url':
f = form.cleaned_data['url']
elif import_type == 'by_name':
name = form.cleaned_data['repo_name']
version = form.cleaned_data['repo_version']
f = muranoclient_utils.to_url(
name,
version=version,
path='/apps/',
extension='.zip',
base_url=base_url,
)
try:
package = muranoclient_utils.Package.from_file(f)
name = package.manifest['FullName']
except Exception as e:
msg = _("Package creation failed" "Reason: {0}").format(e)
LOG.exception(msg)
messages.error(self.request, msg)
raise exceptions.Http302(
reverse('horizon:murano:packages:index'))
def _ensure_images(name, package):
try:
imgs = muranoclient_utils.ensure_images(
glance_client=glance_client,
image_specs=package.images(),
base_url=base_url)
for img in imgs:
msg = _("Added {0}, {1} image to glance").format(
img['name'],
img['id'],
)
messages.success(self.request, msg)
LOG.info(msg)
except Exception as e:
msg = _("Error {0} occurred while installing "
"images for {1}").format(e, name)
messages.error(self.request, msg)
LOG.exception(msg)
reqs = package.requirements(base_url=base_url)
glance_client = glance.glanceclient(self.request, version='1')
original_package = reqs.pop(name)
step_data['dependencies'] = []
for dep_name, dep_package in reqs.iteritems():
_ensure_images(dep_name, dep_package)
try:
files = {dep_name: dep_package.file()}
package = api.muranoclient(self.request).packages.create(
data, files)
messages.success(
self.request,
_('Package {0} uploaded').format(dep_name))
_update_latest_apps(request=self.request,
app_id=package.id)
step_data['dependencies'].append(package)
except exc.HTTPConflict:
msg = _("Package {0} already registered.").format(dep_name)
messages.warning(self.request, msg)
LOG.exception(msg)
except Exception as e:
msg = _("Error {0} occurred while "
"installing package {1}").format(e, dep_name)
messages.error(self.request, msg)
LOG.exception(msg)
continue
# add main packages images
_ensure_images(name, original_package)
# import main package itself
try:
files = {name: original_package.file()}
package = api.muranoclient(self.request).packages.create(
data, files)
messages.success(self.request,
_('Package {0} uploaded').format(name))
_update_latest_apps(request=self.request, app_id=package.id)
step_data['package'] = package
except exc.HTTPConflict:
msg = _("Package with specified name already exists")
LOG.exception(msg)
exceptions.handle(
self.request,
msg,
redirect=reverse('horizon:murano:packages:index'))
except exc.HTTPInternalServerError as e:
self._handle_exception(e)
except exc.HTTPException as e:
reason = muranodashboard_utils.parse_api_error(
getattr(e, 'details', ''))
if not reason:
raise
LOG.exception(reason)
exceptions.handle(
self.request,
reason,
redirect=reverse('horizon:murano:packages:index'))
except Exception as original_e:
self._handle_exception(original_e)
return step_data
def get_form_kwargs(self, step=None):
kwargs = {}
if step == 'add_category':
kwargs.update({'request': self.request})
if step == 'modify':
package = self.storage.get_step_data('upload').get('package')
kwargs.update({'package': package})
return kwargs
def upload(req):
myfile = req.FILES['myfile']
main = fs.FileSystemStorage()
name = main.save(myfile.name, myfile)
return HttpResponse("ok {0}".format(len))
class ImportPackageWizard(horizon_views.PageTitleMixin, views.ModalFormMixin,
wizard_views.SessionWizardView):
file_storage = storage.FileSystemStorage(location=consts.CACHE_DIR)
template_name = 'packages/upload.html'
condition_dict = {'add_category': is_app}
page_title = _("Import Package")
def get_form_initial(self, step):
initial_dict = self.initial_dict.get(step, {})
if step == 'upload':
for name in ['url', 'repo_name', 'repo_version', 'import_type']:
if name in self.request.GET:
initial_dict[name] = self.request.GET[name]
return initial_dict
def get_context_data(self, **kwargs):
context = super(ImportPackageWizard, self).get_context_data(**kwargs)
repo_url = urlparse.urlparse(packages_consts.MURANO_REPO_URL)
context['murano_repo_url'] = "{}://{}".format(repo_url.scheme,
repo_url.netloc)
return context
def done(self, form_list, **kwargs):
data = self.get_all_cleaned_data()
app_id = self.storage.get_step_data('upload')['package'].id
# Remove package file from result data
for key in ('package', 'import_type', 'url', 'repo_version',
'repo_name'):
del data[key]
dep_pkgs = self.storage.get_step_data('upload').get('dependencies', [])
installed_images = self.storage.get_step_data('upload').get(
'images', [])
redirect = reverse('horizon:app-catalog:packages:index')
dep_data = {'enabled': data['enabled'], 'is_public': data['is_public']}
murano_client = api.muranoclient(self.request)
for dep_pkg in dep_pkgs:
try:
murano_client.packages.update(dep_pkg.id, dep_data)
LOG.debug('Success update for package {0}.'.format(dep_pkg.id))
except Exception as e:
msg = _("Couldn't update package {0} parameters. Error: {1}")\
.format(dep_pkg.fully_qualified_name, e)
LOG.warning(msg)
messages.warning(self.request, msg)
# Images have been imported as private images during the 'upload' step
# If the package is public, make the required images public
if data['is_public']:
try:
glance_client = glance.glanceclient(self.request, '1')
except Exception:
glance_client = None
if glance_client:
for img in installed_images:
try:
glance_client.images.update(img['id'], is_public=True)
LOG.debug('Success update for image {0}'.format(
img['id']))
except Exception as e:
msg = _("Error {0} occurred while setting image {1}, "
"{2} public").format(e, img['name'], img['id'])
messages.error(self.request, msg)
LOG.exception(msg)
elif len(installed_images):
msg = _("Couldn't initialise glance v1 client, "
"therefore could not make the following images "
"public: {0}").format(' '.join(
[img['name'] for img in installed_images]))
messages.warning(self.request, msg)
LOG.warning(msg)
try:
data['tags'] = [t.strip() for t in data['tags'].split(',')]
murano_client.packages.update(app_id, data)
except exc.HTTPForbidden:
msg = _("You are not allowed to change"
" this properties of the package")
LOG.exception(msg)
exceptions.handle(
self.request,
msg,
redirect=reverse('horizon:app-catalog:packages:index'))
except (exc.HTTPException, Exception):
LOG.exception(_('Modifying package failed'))
exceptions.handle(self.request,
_('Unable to modify package'),
redirect=redirect)
else:
msg = _('Package parameters successfully updated.')
LOG.info(msg)
messages.success(self.request, msg)
return http.HttpResponseRedirect(redirect)
def _handle_exception(self, original_e):
exc_info = sys.exc_info()
reason = ''
if hasattr(original_e, 'details'):
try:
error = json.loads(original_e.details).get('error')
if error:
reason = error.get('message')
except ValueError:
# Let horizon operate with original exception
six.reraise(original_e.__class__,
original_e.__class__(original_e), exc_info[2])
msg = _('Uploading package failed. {0}').format(reason)
LOG.exception(msg)
exceptions.handle(
self.request,
msg,
redirect=reverse('horizon:app-catalog:packages:index'))
def process_step(self, form):
@catalog_views.update_latest_apps
def _update_latest_apps(request, app_id):
LOG.info('Adding {0} application to the'
' latest apps list'.format(app_id))
step_data = self.get_form_step_data(form).copy()
if self.steps.current == 'upload':
import_type = form.cleaned_data['import_type']
data = {}
f = None
base_url = packages_consts.MURANO_REPO_URL
if import_type == 'upload':
pkg = form.cleaned_data['package']
f = pkg.file
elif import_type == 'by_url':
f = form.cleaned_data['url']
elif import_type == 'by_name':
name = form.cleaned_data['repo_name']
version = form.cleaned_data['repo_version']
f = muranoclient_utils.to_url(
name,
version=version,
path='apps/',
extension='.zip',
base_url=base_url,
)
try:
package = muranoclient_utils.Package.from_file(f)
name = package.manifest['FullName']
except Exception as e:
if '(404)' in e.message:
msg = _("Package creation failed."
"Reason: Can't find Package name from repository.")
else:
msg = _("Package creation failed." "Reason: {0}").format(e)
LOG.exception(msg)
messages.error(self.request, msg)
raise exceptions.Http302(
reverse('horizon:app-catalog:packages:index'))
reqs = package.requirements(base_url=base_url)
original_package = reqs.pop(name)
step_data['dependencies'] = []
step_data['images'] = []
for dep_name, dep_package in six.iteritems(reqs):
_ensure_images(dep_name, dep_package, self.request, step_data)
try:
files = {dep_name: dep_package.file()}
package = api.muranoclient(self.request).packages.create(
data, files)
messages.success(
self.request,
_('Package {0} uploaded').format(dep_name))
_update_latest_apps(request=self.request,
app_id=package.id)
step_data['dependencies'].append(package)
except exc.HTTPConflict:
msg = _("Package {0} already registered.").format(dep_name)
messages.warning(self.request, msg)
LOG.exception(msg)
except Exception as e:
msg = _("Error {0} occurred while "
"installing package {1}").format(e, dep_name)
messages.error(self.request, msg)
LOG.exception(msg)
continue
# add main packages images
_ensure_images(name, original_package, self.request, step_data)
# import main package itself
try:
files = {name: original_package.file()}
package = api.muranoclient(self.request).packages.create(
data, files)
messages.success(self.request,
_('Package {0} uploaded').format(name))
_update_latest_apps(request=self.request, app_id=package.id)
step_data['package'] = package
except exc.HTTPConflict:
msg = _("Package with specified name already exists")
LOG.exception(msg)
exceptions.handle(
self.request,
msg,
redirect=reverse('horizon:app-catalog:packages:index'))
except exc.HTTPInternalServerError as e:
self._handle_exception(e)
except exc.HTTPException as e:
reason = muranodashboard_utils.parse_api_error(
getattr(e, 'details', ''))
if not reason:
raise
LOG.exception(reason)
exceptions.handle(
self.request,
reason,
redirect=reverse('horizon:app-catalog:packages:index'))
except Exception as original_e:
self._handle_exception(original_e)
return step_data
def get_form_kwargs(self, step=None):
kwargs = {}
if step == 'add_category':
kwargs.update({'request': self.request})
if step == 'modify':
package = self.storage.get_step_data('upload').get('package')
kwargs.update({'package': package, 'request': self.request})
return kwargs
from settings_locale import *
if DEBUG:
LOGGING['loggers']['django.request']['handlers'].append('console')
# files under SECURE_MEDIA_BOOT must be served by django, this if
# is needed to avoid they end up in a subdir of MEDIA_ROOT that is
# normally served by an external webserver
import os.path
check = os.path.commonprefix((MEDIA_ROOT, SECURE_MEDIA_ROOT))
if check.startswith(MEDIA_ROOT):
if not DEBUG:
raise RuntimeError(
'SECURE_MEDIA_ROOT cannot be a subdir of MEDIA_ROOT')
else:
print
'WARN, SECURE_MEDIA_ROOT is a subdir of MEDIA_ROOT'
from django.core.files import storage
SECURE_STORAGE = storage.FileSystemStorage(location=SECURE_MEDIA_ROOT,
base_url=SECURE_MEDIA_URL)
if not SECRET_KEY:
if not DEBUG:
raise RuntimeError('SECRET_KEY not set')
else:
print
'WARN, SECRET_KEY not set'
def get_secure_storage():
return storage.FileSystemStorage(
location=settings.SECURE_MEDIA_ROOT,
base_url=settings.SECURE_MEDIA_URL,
)
from datetime import date
# TODO implement proper slicing
# TODO ALL create data and metadata connection
# TODO make nicer upload paths?
def make_upload_path(self, filename):
""" Generates upload path for FileField """
today = date.today().strftime("%Y/%m/%d")
return "%s/%s/%s" % (self.owner.username, today, filename)
fs = storage.FileSystemStorage(location=settings.FILE_MEDIA_ROOT)
DEFAULTS = {
"name_max_length": 100,
"description_max_length": 2048,
"label_max_length": 100,
"unit_max_length": 10,
"default_time_unit": "ms",
"default_data_unit": "mV",
"default_samp_unit": "Hz"
}
# 1 (of 15)
class Block(BasePermissionsMixin, BaseGnodeObject):
"""