def test_mashup_with_invalid_embedded_resources(self):
file_contents = WgtFile(
BytesIO(
self.read_file("..", "..", "..", "commons", "test-data",
"Wirecloud_mashup-with-invalid-macs_1.0.wgt")))
try:
install_component(file_contents,
executor_user=self.user,
users=[self.user])
self.fail('InvalidContents exception not raised')
except InvalidContents as e:
self.assertIn('Invalid embedded file: ', e.message)
def test_widget_code_cache(self):
client = Client()
client.login(username='******', password='******')
widget_code_path = {
'vendor': 'Wirecloud',
'name': 'test',
'version': '0.1',
'file_path': 'index.html'
}
file_contents = self.build_simple_wgt('template1.xml',
other_files=('doc/index.html', ))
added, resource = install_component(file_contents,
executor_user=self.user,
users=[self.user])
self.assertTrue(added)
resource_pk = resource.pk
xhtml_pk = resource.widget.pk
# Cache widget code
response = client.get(
reverse('wirecloud.showcase_media', kwargs=widget_code_path) +
'?entrypoint=true')
self.assertEqual(response.status_code, 200)
old_code = response.content
resource.delete()
self.assertRaises(XHTML.DoesNotExist, XHTML.objects.get, pk=xhtml_pk)
self.assertRaises(Widget.DoesNotExist,
Widget.objects.get,
resource__pk=resource_pk)
self.assertRaises(CatalogueResource.DoesNotExist,
CatalogueResource.objects.get,
pk=resource_pk)
# Use a different xhtml code
file_contents = self.build_simple_wgt('template1.xml',
b'code',
other_files=('doc/index.html', ))
resource = install_component(file_contents,
executor_user=self.user,
users=[self.user])
response = client.get(
reverse('wirecloud.showcase_media', kwargs=widget_code_path) +
'?entrypoint=true')
self.assertEqual(response.status_code, 200)
new_code = response.content
self.assertNotEqual(old_code, new_code)
def test_basic_packaged_widget_deployment(self):
wgt_file = WgtFile(
os.path.join(os.path.dirname(__file__), 'test-data',
'basic_widget.wgt'))
catalogue_deployment_path = catalogue.wgt_deployer.get_base_dir(
'Wirecloud', 'Test', '0.1')
deployment_path = wirecloud.platform.widget.utils.wgt_deployer.get_base_dir(
'Wirecloud', 'Test', '0.1')
added, resource = install_component(wgt_file, users=[self.user])
resource.widget
self.assertTrue(added)
self.assertTrue(os.path.isdir(deployment_path))
self.assertTrue(os.path.isdir(catalogue_deployment_path))
self.assertTrue(resource.is_available_for(self.user))
resource.delete()
self.assertRaises(CatalogueResource.DoesNotExist,
CatalogueResource.objects.get,
vendor='Wirecloud',
short_name='Test',
version='0.1')
self.assertFalse(os.path.exists(deployment_path))
self.assertFalse(os.path.exists(catalogue_deployment_path))
def create(self, request):
file_contents = None
if request.mimetype == 'multipart/form-data':
public = request.POST.get('public',
'true').strip().lower() == 'true'
if 'file' not in request.FILES:
return build_error_response(
request, 400, _('Missing component file in the request'))
downloaded_file = request.FILES['file']
else: # if request.mimetype == 'application/octet-stream'
downloaded_file = BytesIO(request.body)
public = request.GET.get('public',
'true').strip().lower() == 'true'
try:
file_contents = WgtFile(downloaded_file)
except zipfile.BadZipfile:
return build_error_response(
request, 400, _('The uploaded file is not a zip file'))
try:
added, resource = install_component(file_contents,
executor_user=request.user,
public=public,
users=(request.user, ),
restricted=True)
if not added:
return build_error_response(request, 409,
_('Resource already exists'))
except OSError as e:
if e.errno == errno.EACCES:
return build_error_response(
request, 500,
_('Error writing the resource into the filesystem. Please, contact the server administrator.'
))
else:
raise
except TemplateParseException as e:
msg = "Error parsing config.xml descriptor file"
return build_error_response(request, 400, msg, details=str(e))
except InvalidContents as e:
details = e.details if hasattr(e, 'details') else None
return build_error_response(request, 400, e, details=str(details))
response = HttpResponse(status=(201 if added else 204))
response['Location'] = resource.get_template_url()
return response
def test_basic_widget_creation_from_rdf(self):
file_contents = self.build_simple_wgt('template1.rdf',
other_files=('doc/index.html', ))
added, resource = install_component(file_contents,
executor_user=self.user,
users=[self.user])
self.assertTrue(added)
self.check_basic_widget_info(resource)
def test_install_resource_to_group(self):
wgt_file = self.build_simple_wgt('template1.xml',
b'code',
other_files=('doc/index.html', ))
added, resource = install_component(wgt_file, groups=[self.group])
self.assertTrue(added)
self.assertTrue(resource.is_available_for(self.user))
self.assertTrue(resource.is_available_for(self.user2))
def test_basic_packaged_mashup_deployment(self):
wgt_file = WgtFile(
os.path.join(os.path.dirname(wirecloud.commons.__file__),
'test-data', 'Wirecloud_PackagedTestMashup_1.0.zip'))
deployment_path = catalogue.wgt_deployer.get_base_dir(
'Wirecloud', 'PackagedTestMashup', '1.0')
install_component(wgt_file, users=[self.user])
resource = CatalogueResource.objects.get(
vendor='Wirecloud', short_name='PackagedTestMashup', version='1.0')
self.assertTrue(os.path.isdir(deployment_path))
resource.delete()
self.assertRaises(CatalogueResource.DoesNotExist,
CatalogueResource.objects.get,
vendor='Wirecloud',
short_name='PackagedTestMashup',
version='1.0')
self.assertFalse(os.path.exists(deployment_path))
def test_basic_mashup_rdf(self):
file_contents = self.build_simple_wgt(
os.path.join('..', '..', 'workspace', 'test-data', 'wt1.rdf'))
added, resource = install_component(file_contents,
executor_user=self.user,
users=[self.user])
self.assertTrue(added)
self.assertEqual(resource.vendor, 'Wirecloud Test Suite')
self.assertEqual(resource.short_name, 'test-mashup')
self.assertEqual(resource.version, '1')
self.assertTrue(resource.is_available_for(self.user))
def test_install_resource_to_all_users_duplicated(self):
CatalogueResource.objects.filter(vendor='Test',
short_name='Test Widget',
version='1.0.0').update(public=True)
wgt_file = self.build_simple_wgt('template10.xml', b'code')
added, resource = install_component(wgt_file, public=True)
self.assertFalse(added)
self.assertTrue(resource.public)
self.assertTrue(resource.is_available_for(self.user))
self.assertTrue(resource.is_available_for(self.user2))
def test_install_resource_to_group_duplicated(self):
resource = CatalogueResource.objects.get(vendor='Test',
short_name='Test Widget',
version='1.0.0')
resource.groups.add(self.group)
wgt_file = self.build_simple_wgt('template10.xml', b'code')
added, resource = install_component(wgt_file, groups=[self.group])
self.assertFalse(added)
self.assertTrue(resource.is_available_for(self.user))
self.assertTrue(resource.is_available_for(self.user2))
def publish(self, endpoint, wgt_file, user, request=None, template=None):
if self._name == 'local':
if template is None:
template = TemplateParser(wgt_file.get_template())
added, resource = install_component(wgt_file, users=[user])
if not added:
raise Exception(
_('Resource already exists %(resource_id)s') %
{'resource_id': resource.local_uri_part})
return resource
else:
raise Exception('TODO')
def populate(self, wirecloud_user, log):
updated = False
if not CatalogueResource.objects.filter(vendor="CoNWeT",
short_name="bae-browser",
version="0.1.1",
public=True).exists():
updated = True
log('Installing bae-browser widget... ', 1, ending='')
install_component(WgtFile(BAE_BROWSER_WIDGET), public=True)
log('DONE', 1)
if not CatalogueResource.objects.filter(vendor="CoNWeT",
short_name="bae-details",
version="0.1.1",
public=True).exists():
updated = True
log('Installing bae-details widget... ', 1, ending='')
install_component(WgtFile(BAE_DETAILS_WIDGET), public=True)
log('DONE', 1)
if not CatalogueResource.objects.filter(
vendor="CoNWeT",
short_name="bae-search-filters",
version="0.1.1",
public=True).exists():
updated = True
log('Installing bae-search-filters widget... ', 1, ending='')
install_component(WgtFile(BAE_SEARCH_FILTERS_WIDGET), public=True)
log('DONE', 1)
if not CatalogueResource.objects.filter(vendor="CoNWeT",
short_name="bae-marketplace",
version="0.1.1",
public=True).exists():
updated = True
log('Installing bae-marketplace mashup... ', 1, ending='')
install_component(WgtFile(BAE_MASHUP), public=True)
log('DONE', 1)
return updated
def test_widget_with_minimal_info(self):
file_contents = self.build_simple_wgt('template9.xml')
added, resource = install_component(file_contents,
executor_user=self.user,
users=[self.user])
self.assertTrue(added)
resource_info = resource.json_description
self.assertEqual(resource.vendor, 'Wirecloud')
self.assertEqual(resource.short_name, 'test')
self.assertEqual(resource.version, '0.1')
self.assertEqual(resource_info['email'], '*****@*****.**')
self.assertFalse(resource.public)
self.assertEqual(
tuple(resource.users.values_list('username', flat=True)),
('test', ))
self.assertEqual(tuple(resource.groups.values_list('name', flat=True)),
())
def populate_component(self, wirecloud_user, log, vendor, name, version,
wgt):
if not CatalogueResource.objects.filter(
vendor=vendor, short_name=name, version=version).exists():
log('Installing the %(name)s widget... ' % {"name": name},
1,
ending='')
added, component = install_component(WgtFile(wgt),
executor_user=wirecloud_user,
users=[wirecloud_user])
IWidget.objects.filter(
widget__resource__vendor=vendor,
widget__resource__short_name=name).exclude(
widget__resource__version=version).update(
widget=component.widget,
widget_uri=component.local_uri_part)
log('DONE', 1)
return True
return False
def _handle(self, *args, **options):
self.verbosity = int(options.get('verbosity', 1))
users = []
groups = []
redeploy = options['redeploy']
public = options['public']
users_string = options['users'].strip()
groups_string = options['groups'].strip()
if redeploy is False and public is False and users_string == '' and groups_string == '':
raise CommandError(
_('You must use at least one of the following flags: --redeploy, --users, --groups or --public'
))
if not options['redeploy']:
if users_string != '':
for username in users_string.split(','):
users.append(User.objects.get(username=username))
if groups_string != '':
for groupname in groups_string.split(','):
groups.append(Group.objects.get(name=groupname))
for file_name in options['files']:
try:
f = open(file_name, 'rb')
wgt_file = WgtFile(f)
except:
self.log(_('Failed to read from %(file_name)s') %
{'file_name': file_name},
level=1)
continue
try:
template_contents = wgt_file.get_template()
template = TemplateParser(template_contents)
if options['redeploy']:
add_packaged_resource(f,
None,
wgt_file=wgt_file,
template=template,
deploy_only=True)
else:
install_component(wgt_file,
public=public,
users=users,
groups=groups)
wgt_file.close()
f.close()
self.log(_(
'Successfully imported \"%(name)s\" from \"%(file_name)s\"'
) % {
'name':
template.get_resource_processed_info()['title'],
'file_name':
file_name
},
level=1)
except:
self.log(_(
'Failed to import the mashable application component from %(file_name)s'
) % {'file_name': file_name},
level=1)
def create(self, request):
status_code = 201
force_create = False
install_embedded_resources = False
templateURL = None
file_contents = None
if request.mimetype == 'multipart/form-data':
force_create = request.POST.get('force_create',
'false').strip().lower() == 'true'
public = request.POST.get('public',
'false').strip().lower() == 'true'
user_list = set(
user.strip()
for user in request.POST.get('users', '').split(',')
if user != "")
group_list = set(
group.strip()
for group in request.POST.get('groups', '').split(',')
if group != "")
install_embedded_resources = request.POST.get(
'install_embedded_resources',
'false').strip().lower() == 'true'
if 'file' not in request.FILES:
return build_error_response(
request, 400, _('Missing component file in the request'))
downloaded_file = request.FILES['file']
try:
file_contents = WgtFile(downloaded_file)
except zipfile.BadZipfile:
return build_error_response(
request, 400, _('The uploaded file is not a zip file'))
elif request.mimetype == 'application/octet-stream':
downloaded_file = BytesIO(request.body)
try:
file_contents = WgtFile(downloaded_file)
except zipfile.BadZipfile:
return build_error_response(
request, 400, _('The uploaded file is not a zip file'))
force_create = request.GET.get('force_create',
'false').strip().lower() == 'true'
public = request.GET.get('public',
'false').strip().lower() == 'true'
user_list = set(user.strip()
for user in request.GET.get('users', '').split(',')
if user != "")
group_list = set(
group.strip()
for group in request.GET.get('groups', '').split(',')
if group != "")
install_embedded_resources = request.GET.get(
'install_embedded_resources',
'false').strip().lower() == 'true'
else: # if request.mimetype == 'application/json'
market_endpoint = None
data = parse_json_request(request)
install_embedded_resources = normalize_boolean_param(
request, 'install_embedded_resources',
data.get('install_embedded_resources', False))
force_create = data.get('force_create', False)
public = request.GET.get('public',
'false').strip().lower() == 'true'
user_list = set(
user.strip()
for user in request.GET.get('user_list', '').split(',')
if user != "")
group_list = set(
group.strip()
for group in request.GET.get('group_list', '').split(',')
if group != "")
templateURL = data.get('url')
market_endpoint = data.get('market_endpoint', None)
headers = data.get('headers', {})
headers['Accept-Encoding'] = 'identity'
if market_endpoint is not None:
if 'name' not in market_endpoint:
msg = _('Missing market name')
return build_error_response(request, 400, msg)
market_id = market_endpoint['name']
market_managers = get_market_managers(request.user)
if market_id not in market_managers:
return build_error_response(
request, 409,
_('Unknown market: %s') % market_id)
market_manager = market_managers[market_id]
downloaded_file = market_manager.download_resource(
request.user, templateURL, market_endpoint)
else:
try:
context = parse_context_from_referer(request)
except Exception:
context = {}
try:
context["headers"] = CaseInsensitiveDict(headers)
response = WIRECLOUD_PROXY.do_request(
request, templateURL, "GET", context)
if response.status_code >= 300 or response.status_code < 200:
raise Exception()
downloaded_file = b''.join(response)
except Exception:
return build_error_response(
request, 409,
_('Content cannot be downloaded from the specified url'
))
try:
downloaded_file = BytesIO(downloaded_file)
file_contents = WgtFile(downloaded_file)
except zipfile.BadZipfile:
return build_error_response(
request, 400,
_('The file downloaded from the marketplace is not a zip file'
))
if public is False and len(user_list) == 0 and len(group_list) == 0:
users = (request.user, )
else:
users = User.objects.filter(username__in=user_list)
groups = Group.objects.filter(name__in=group_list)
if not request.user.is_superuser:
if public:
return build_error_response(
request, 403,
_('You are not allowed to make resources publicly available to all users'
))
elif len(users) > 0 and tuple(users) != (request.user, ):
return build_error_response(
request, 403,
_('You are not allowed allow to install components to other users'
))
elif len(groups) > 0:
for group in groups:
try:
owners = group.organization.team_set.get(name="owners")
except ObjectDoesNotExist:
fail = True
else:
fail = owners.users.filter(
id=request.user.id).exists() is False
if fail:
return build_error_response(
request, 403,
_('You are not allowed to install components to non-owned organizations'
))
try:
fix_dev_version(file_contents, request.user)
added, resource = install_component(file_contents,
executor_user=request.user,
public=public,
users=users,
groups=groups)
if not added and force_create:
return build_error_response(request, 409,
_('Resource already exists'))
elif not added:
status_code = 200
except zipfile.BadZipfile as e:
return build_error_response(
request,
400,
_('The uploaded file is not a valid zip file'),
details="{}".format(e))
except OSError as e:
if e.errno == errno.EACCES:
return build_error_response(
request, 500,
_('Error writing the resource into the filesystem. Please, contact the server administrator.'
))
else:
raise
except TemplateParseException as e:
msg = "Error parsing config.xml descriptor file: %s" % e
details = "%s" % e
return build_error_response(request, 400, msg, details=details)
except (InvalidContents, UnsupportedFeature) as e:
details = e.details if hasattr(e, 'details') else None
return build_error_response(request, 400, e, details=str(details))
if install_embedded_resources:
info = {
'resource_details':
resource.get_processed_info(
request, url_pattern_name="wirecloud.showcase_media"),
'extra_resources': []
}
if resource.resource_type() == 'mashup':
resource_info = resource.get_processed_info(process_urls=False)
for embedded_resource in resource_info['embedded']:
resource_file = BytesIO(
file_contents.read(embedded_resource['src']))
extra_resource_contents = WgtFile(resource_file)
extra_resource_added, extra_resource = install_component(
extra_resource_contents,
executor_user=request.user,
public=public,
users=users,
groups=groups)
if extra_resource_added:
info['extra_resources'].append(
extra_resource.get_processed_info(
request,
url_pattern_name="wirecloud.showcase_media"))
response = HttpResponse(
json.dumps(info, sort_keys=True),
status=status_code,
content_type='application/json; charset=UTF-8')
else:
response = HttpResponse(
json.dumps(resource.get_processed_info(
request, url_pattern_name="wirecloud.showcase_media"),
sort_keys=True),
status=status_code,
content_type='application/json; charset=UTF-8')
response['Location'] = resource.get_template_url()
return response
def test_template_translations(self):
file_contents = self.build_simple_wgt('template1.xml',
other_files=('doc/index.html', ))
added, resource = install_component(file_contents,
executor_user=self.user,
users=[self.user])
self.assertTrue(added)
self.changeLanguage('es')
data = resource.get_processed_info(process_urls=False)
self.assertEqual(data['vendor'], 'Wirecloud')
self.assertEqual(data['name'], 'test')
self.assertEqual(data['version'], '0.1')
self.assertEqual(data['title'], 'Widget de prueba')
self.assertEqual(data['description'],
'Descripción del Widget de pruebas')
self.assertEqual(data['image'], 'images/catalogue.png')
self.assertEqual(data['smartphoneimage'],
'images/catalogue_smartphone.png')
self.assertEqual(data['doc'], 'doc/index.html')
self.assertEqual(len(data['properties']), 1)
self.assertEqual(data['properties'], [{
'default': '',
'secure': False,
'name': 'prop',
'label': 'Etiqueta de la propiedad',
'type': 'text',
'description': '',
'multiuser': False
}])
self.assertEqual(len(data['preferences']), 1)
self.assertEqual(
data['preferences'],
[{
'default': 'value',
'secure': False,
'name': 'pref',
'label': 'Etiqueta de la preferencia',
'type': 'list',
'options': [{
'value': '1',
'label': 'Nombre de la opción'
}],
'readonly': False,
'description': 'Descripción de la preferencia',
'value': None,
'multiuser': False,
'required': False,
}])
self.assertEqual(len(data['wiring']['inputs']), 1)
self.assertEqual(data['wiring']['inputs'], [{
'name': 'slot',
'label': 'Etiqueta del endpoint de entrada',
'type': 'text',
'description': '',
'friendcode': 'test_friend_code',
'actionlabel': ''
}])
self.assertEqual(len(data['wiring']['outputs']), 1)
self.assertEqual(data['wiring']['outputs'],
[{
'name': 'event',
'label': 'Etiqueta del endpoint de salida',
'type': 'text',
'description': '',
'friendcode': 'test_friend_code'
}])
def create_workspace(owner,
f=None,
mashup=None,
new_name=None,
new_title=None,
preferences={},
searchable=True,
public=False):
from wirecloud.platform.workspace.mashupTemplateParser import buildWorkspaceFromTemplate
if mashup is not None and f is not None:
raise Exception
if f is not None:
wgt = f if isinstance(f, WgtFile) else WgtFile(f)
template = TemplateParser(wgt.get_template())
resource_info = template.get_resource_processed_info(
process_urls=False)
if resource_info["type"] != 'mashup':
raise Exception
for embedded_resource in resource_info['embedded']:
if embedded_resource['src'].startswith('https://'):
resource_file = download_http_content(embedded_resource['src'])
else:
resource_file = BytesIO(wgt.read(embedded_resource['src']))
extra_resource_contents = WgtFile(resource_file)
install_component(extra_resource_contents,
executor_user=owner,
users=[owner])
else:
values = mashup.split('/', 3)
if len(values) != 3:
raise TypeError(_('invalid mashup id'))
(mashup_vendor, mashup_name, mashup_version) = values
try:
resource = CatalogueResource.objects.get(vendor=mashup_vendor,
short_name=mashup_name,
version=mashup_version)
if not resource.is_available_for(
owner) or resource.resource_type() != 'mashup':
raise CatalogueResource.DoesNotExist
except CatalogueResource.DoesNotExist:
raise Exception(
_('Mashup not found: %(mashup)s') % {'mashup': mashup})
base_dir = catalogue.wgt_deployer.get_base_dir(mashup_vendor,
mashup_name,
mashup_version)
wgt_file = WgtFile(os.path.join(base_dir, resource.template_uri))
template = TemplateParser(wgt_file.get_template())
workspace, _foo = buildWorkspaceFromTemplate(template,
owner,
new_name=new_name,
new_title=new_title,
searchable=searchable,
public=public)
if len(preferences) > 0:
update_workspace_preferences(workspace,
preferences,
invalidate_cache=False)
return workspace
