def wrapper(self, *args, **kwargs):
owner_user = User.objects.get(username=owner)
if shared:
base = self.shared_test_data_dir
else:
base = self.test_data_dir
with open(os.path.join(base, file_name), 'rb') as f:
wgt = 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_resource_to_user(
owner_user, file_contents=extra_resource_contents)
buildWorkspaceFromTemplate(template, owner_user)
return test_func(self, *args, **kwargs)
def test_widget_code_cache(self):
template_uri = "http://example.com/path/widget.xml"
template = self.read_template("template1.xml")
client = Client()
client.login(username="******", password="******")
widget_id = {"vendor": "Wirecloud", "name": "test", "version": "0.1"}
self.network._servers["http"]["example.com"].add_response("GET", "/path/widget.xml", {"content": template})
self.network._servers["http"]["example.com"].add_response(
"GET", "/path/test.html", {"content": BASIC_HTML_GADGET_CODE}
)
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
resource_pk = resource.pk
xhtml_pk = resource.widget.pk
# Cache widget code
response = client.get(reverse("wirecloud.widget_code_entry", kwargs=widget_id))
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
self.network._servers["http"]["example.com"].add_response("GET", "/path/test.html", {"content": "cache"})
install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
response = client.get(reverse("wirecloud.widget_code_entry", kwargs=widget_id))
self.assertEqual(response.status_code, 200)
new_code = response.content
self.assertNotEqual(old_code, new_code)
def wrapper(self, *args, **kwargs):
owner_user = User.objects.get(username=owner)
if shared:
base = self.shared_test_data_dir
else:
base = self.test_data_dir
with open(os.path.join(base, file_name), 'rb') as f:
wgt = 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_resource_to_user(owner_user, file_contents=extra_resource_contents)
buildWorkspaceFromTemplate(template, owner_user)
return test_func(self, *args, **kwargs)
def test_widget_code_cache(self):
client = Client()
client.login(username='******', password='******')
widget_id = {'vendor': 'Wirecloud', 'name': 'test', 'version': '0.1'}
file_contents = self.build_simple_wgt('template1.xml', other_files=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html'))
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
resource_pk = resource.pk
xhtml_pk = resource.widget.pk
# Cache widget code
response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id))
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=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html'))
resource = install_resource_to_user(self.user, file_contents=file_contents)
response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id))
self.assertEqual(response.status_code, 200)
new_code = response.content
self.assertNotEqual(old_code, new_code)
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_resource_to_user(self.user, file_contents=file_contents)
self.fail('InvalidContents exception not raised')
except InvalidContents as e:
self.assertIn('Invalid embedded file: ', e.message)
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())
install_resource_to_user(user, file_contents=wgt_file, packaged=True, raise_conflicts=True)
else:
raise Exception('TODO')
def _handle(self, *args, **options):
if len(args) < 1:
raise CommandError(_('Wrong number of arguments'))
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 args:
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:
for user in users:
install_resource_to_user(user, file_contents=wgt_file)
for group in groups:
install_resource_to_group(group, file_contents=wgt_file)
if public:
install_resource_to_all_users(file_contents=wgt_file)
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 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_resource_to_user(self.user, file_contents=file_contents)
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=('images/catalogue.png', 'images/catalogue_iphone.png',
'doc/index.html'))
added, resource = install_resource_to_user(self.user,
file_contents=file_contents)
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=('images/catalogue.png', 'images/catalogue_iphone.png',
'doc/index.html'))
resource = install_resource_to_user(self.user,
file_contents=file_contents)
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_operator_deployment(self):
wgt_file = WgtFile(os.path.join(os.path.dirname(wirecloud.commons.__file__), 'test-data', 'Wirecloud_TestOperator_1.0.zip'))
deployment_path = catalogue.wgt_deployer.get_base_dir('Wirecloud', 'TestOperator', '1.0')
install_resource_to_user(self.user, file_contents=wgt_file)
resource = CatalogueResource.objects.get(vendor='Wirecloud', short_name='TestOperator', version='1.0')
self.assertTrue(os.path.isdir(deployment_path))
resource.delete()
self.assertRaises(CatalogueResource.DoesNotExist, CatalogueResource.objects.get, vendor='Wirecloud', short_name='TestOperator', version='1.0')
self.assertFalse(os.path.exists(deployment_path))
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_resource_to_user(self.user,
file_contents=wgt_file)
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 deploy_tenant_ac(request):
result = _parse_ac_request(request)
if isinstance(result, HttpResponse):
return result
id_4CaaSt, wgt_file, fileURL = result
# Process 4CaaSt Id
username = parse_username(id_4CaaSt)
user = get_object_or_404(User, username=username)
# Install uploaded MAC resource
try:
resource = install_resource_to_user(user, file_contents=wgt_file)
except TemplateParseException as e:
return build_error_response(request, 400, e.msg)
# Create a workspace if the resource is a mashup
if resource.resource_type() == 'mashup' and not Workspace.objects.filter(
creator=user, name=resource.short_name).exists():
buildWorkspaceFromTemplate(resource.get_template(), user, True)
return HttpResponse(status=204)
def deploy_tenant_ac(request):
result = _parse_ac_request(request)
if isinstance(result, HttpResponse):
return result
id_4CaaSt, wgt_file, fileURL = result
# Process 4CaaSt Id
username = parse_username(id_4CaaSt)
user = get_object_or_404(User, username=username)
# Install uploaded MAC resource
try:
resource = install_resource_to_user(user, file_contents=wgt_file)
except TemplateParseException as e:
return build_error_response(request, 400, e.msg)
# Create a workspace if the resource is a mashup
if resource.resource_type() == 'mashup' and not Workspace.objects.filter(creator=user, name=resource.short_name).exists():
buildWorkspaceFromTemplate(resource.get_template(), user, True)
return HttpResponse(status=204)
def test_basic_widget_creation(self):
file_contents = self.build_simple_wgt('template1.xml', other_files=('doc/index.html',))
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
self.check_basic_widget_info(resource)
def test_basic_widget_creation_from_rdf(self):
file_contents = self.build_simple_wgt('template1.rdf', other_files=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html'))
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
self.check_basic_widget_info(resource)
def test_template_translations(self):
template_uri = "http://example.com/path/widget.xml"
template = self.read_template('template1.xml')
self.network._servers['http']['example.com'].add_response('GET', '/path/widget.xml', {'content': template})
self.network._servers['http']['example.com'].add_response('GET', '/path/test.html', {'content': BASIC_HTML_GADGET_CODE})
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
self.changeLanguage('es')
data = resource.get_processed_info()
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'], u'Descripción del Widget de pruebas')
self.assertEqual(data['image'], 'http://example.com/path/images/catalogue.png')
self.assertEqual(data['smartphoneimage'], 'http://example.com/path/images/catalogue_iphone.png')
self.assertEqual(data['doc'], 'http://example.com/path/doc/index.html')
self.assertEqual(len(data['properties']), 1)
self.assertEqual(data['properties'], [{u'default': u'', u'secure': False, u'name': u'prop', u'label': u'Etiqueta de la propiedad', u'type': u'text', u'description': u''}])
self.assertEqual(len(data['preferences']), 1)
self.assertEqual(data['preferences'], [{u'default': u'value', u'secure': False, u'name': u'pref', u'label': u'Etiqueta de la preferencia', u'type': u'list', u'options': [{u'value': u'1', u'label': u'Nombre de la opción'}], u'readonly': False, u'description': u'Descripción de la preferencia', u'value': None}])
self.assertEqual(len(data['wiring']['inputs']), 1)
self.assertEqual(data['wiring']['inputs'], [{u'name': u'slot', u'label': u'Etiqueta del endpoint de entrada', u'type': u'text', u'description': u'',u'friendcode': u'test_friend_code', u'actionlabel': u''}])
self.assertEqual(len(data['wiring']['outputs']), 1)
self.assertEqual(data['wiring']['outputs'], [{u'name': u'event', u'label': u'Etiqueta del endpoint de salida', u'type': u'text', u'description': u'', u'friendcode': u'test_friend_code'}])
def test_basic_widget_creation(self):
template_uri = "http://example.com/path/widget.xml"
template = self.read_template('template1.xml')
downloader.download_http_content.set_response(template_uri, template)
downloader.download_http_content.set_response('http://example.com/path/test.html', BASIC_HTML_GADGET_CODE)
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
self.assertEqual(resource.vendor, 'Wirecloud')
self.assertEqual(resource.short_name, 'test')
self.assertEqual(resource.version, '0.1')
self.assertEqual(resource.public, False)
self.assertEqual(tuple(resource.users.values_list('username', flat=True)), (u'test',))
self.assertEqual(tuple(resource.groups.values_list('name', flat=True)), ())
widget = resource.widget
self.changeLanguage('en')
data = get_widget_data(widget)
self.assertEqual(data['uri'], 'Wirecloud/test/0.1')
self.assertEqual(data['vendor'], 'Wirecloud')
self.assertEqual(data['name'], 'test')
self.assertEqual(data['version'], '0.1')
self.assertEqual(data['variables']['prop']['label'], 'Property label')
self.assertEqual(data['variables']['prop']['aspect'], 'PROP')
self.assertEqual(data['variables']['pref']['label'], 'Preference label')
self.assertEqual(data['variables']['pref']['value_options'], [['1', 'Option name']])
self.assertEqual(data['variables']['pref']['aspect'], 'PREF')
self.assertEqual(data['variables']['event']['label'], 'Event label')
self.assertEqual(data['variables']['event']['aspect'], 'EVEN')
self.assertEqual(data['variables']['slot']['label'], 'Slot label')
self.assertEqual(data['variables']['slot']['aspect'], 'SLOT')
def test_template_translations(self):
file_contents = self.build_simple_wgt('template1.xml', other_files=('images/catalogue.png', 'images/catalogue_iphone.png', 'doc/index.html'))
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
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_iphone.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': ''}])
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}])
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 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('Morfeo', 'Test', '0.1')
deployment_path = wirecloud.platform.widget.utils.wgt_deployer.get_base_dir('Morfeo', 'Test', '0.1')
install_resource_to_user(self.user, file_contents=wgt_file, packaged=True)
resource = CatalogueResource.objects.get(vendor='Morfeo', short_name='Test', version='0.1')
resource.widget
self.assertTrue(os.path.isdir(deployment_path))
self.assertTrue(os.path.isdir(catalogue_deployment_path))
resource.delete()
self.assertRaises(CatalogueResource.DoesNotExist, CatalogueResource.objects.get, vendor='Morfeo', short_name='Test', version='0.1')
self.assertFalse(os.path.exists(deployment_path))
self.assertFalse(os.path.exists(catalogue_deployment_path))
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_resource_to_user(owner, file_contents=extra_resource_contents)
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
def populate_component(self, wirecloud_user, log, vendor, name, version, wgt):
if not CatalogueResource.objects.filter(vendor=vendor, short_name=name, version=version).exists():
updated = True
log('Installing the %(name)s widget... ' % {"name": name}, 1, ending='')
added, component = install_resource_to_user(wirecloud_user, file_contents=WgtFile(wgt))
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)
def test_basic_widget_creation(self):
file_contents = self.build_simple_wgt(
"template1.xml", other_files=("images/catalogue.png", "images/catalogue_iphone.png", "doc/index.html")
)
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
self.check_basic_widget_info(resource)
def test_basic_widget_creation_from_rdf(self):
file_contents = self.build_simple_wgt('template1.rdf',
other_files=('doc/index.html', ))
added, resource = install_resource_to_user(self.user,
file_contents=file_contents)
self.assertTrue(added)
self.check_basic_widget_info(resource)
def test_basic_mashup_rdf(self):
file_contents = self.build_simple_wgt(os.path.join('..', '..', 'workspace', 'test-data', 'wt1.rdf'))
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
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_basic_mashup_rdf(self):
file_contents = self.build_simple_wgt(os.path.join("..", "..", "workspace", "test-data", "wt1.rdf"))
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
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_basic_mashup_rdf(self):
template_uri = "http://example.com/path/mashup.rdf"
template = self.read_template('..', '..', 'workspace', 'test-data', 'wt1.rdf')
self.network._servers['http']['example.com'].add_response('GET', '/path/mashup.rdf', {'content': template})
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
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_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_resource_to_user(self.user, file_contents=wgt_file)
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):
template_uri = "http://example.com/path/mashup.rdf"
template = self.read_template("..", "..", "workspace", "test-data", "wt1.rdf")
self.network._servers["http"]["example.com"].add_response("GET", "/path/mashup.rdf", {"content": template})
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
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_basic_mashup_rdf(self):
template_uri = "http://example.com/path/mashup.rdf"
template = self.read_template('..', '..', 'workspace', 'test-data', 'wt1.rdf')
downloader.download_http_content.set_response(template_uri, template)
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
self.assertEqual(resource.vendor, 'Wirecloud Test Suite')
self.assertEqual(resource.short_name, 'Test Workspace')
self.assertEqual(resource.version, '1')
self.assertTrue(resource.is_available_for(self.user))
def test_basic_widget_creation(self):
file_contents = self.build_simple_wgt(
'template1.xml',
other_files=('images/catalogue.png', 'images/catalogue_iphone.png',
'doc/index.html'))
added, resource = install_resource_to_user(self.user,
file_contents=file_contents)
self.assertTrue(added)
self.check_basic_widget_info(resource)
def test_basic_mashup_rdf(self):
file_contents = self.build_simple_wgt(
os.path.join('..', '..', 'workspace', 'test-data', 'wt1.rdf'))
added, resource = install_resource_to_user(self.user,
file_contents=file_contents)
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 create_workspace(owner, f):
from wirecloud.platform.workspace.mashupTemplateParser import buildWorkspaceFromTemplate
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_resource_to_user(owner, file_contents=extra_resource_contents)
workspace, _ = buildWorkspaceFromTemplate(template, owner)
return workspace
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_resource_to_user(self.user, file_contents=wgt_file, packaged=True)
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 create_workspace(owner, f):
from wirecloud.platform.workspace.mashupTemplateParser import buildWorkspaceFromTemplate
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_resource_to_user(owner, file_contents=extra_resource_contents)
workspace, _ = buildWorkspaceFromTemplate(template, owner)
return workspace
def deploy_tenant_ac(request):
id_4CaaSt, wgt_file, fileURL = _parse_ac_request(request)
# Process 4CaaSt Id
username = parse_username(id_4CaaSt)
user = get_object_or_404(User, username=username)
try:
if user.tenantprofile_4CaaSt.id_4CaaSt != id_4CaaSt:
raise Http404
except TenantProfile.DoesNotExist:
raise Http404
# Install uploaded MAC resource
try:
install_resource_to_user(user, file_contents=wgt_file, templateURL=fileURL, packaged=True)
except TemplateParseException, e:
return build_error_response(request, 400, unicode(e.msg))
def _handle(self, *args, **options):
updated = False
self.verbosity = int(options.get('verbosity', 1))
with atomic():
wirecloud_user, created = User.objects.get_or_create(
username='******', defaults={'password': '******'})
if created:
updated = True
self.log('Creating a wirecloud user... DONE', 1)
if not CatalogueResource.objects.filter(
vendor="WireCloud",
short_name="workspace-browser",
version="0.1.1").exists():
updated = True
self.log('Installing the workspace-browser widget... ',
1,
ending='')
install_resource_to_user(
wirecloud_user, file_contents=WgtFile(WORKSPACE_BROWSER))
self.log('DONE', 1)
if not Workspace.objects.filter(creator__username="******",
name="home").exists():
updated = True
self.log(
'Creating a initial version of the wirecloud/home workspace... ',
1,
ending='')
with open(INITIAL_HOME_DASHBOARD_FILE, 'rb') as f:
workspace = create_workspace(wirecloud_user, f)
workspace.public = True
workspace.save()
self.log('DONE', 1)
if not updated:
self.log('Already up-to-date.', 1)
def test_widget_with_minimal_info(self):
file_contents = self.build_simple_wgt("template9.xml")
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
resource_info = json.loads(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 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_resource_to_user(user, file_contents=wgt_file, packaged=True, raise_conflicts=True)
if not added:
raise Exception(_('Resource already exists %(resource_id)s') % {'resource_id': resource.local_uri_part})
return resource
else:
raise Exception('TODO')
def test_widget_with_minimal_info(self):
file_contents = self.build_simple_wgt('template9.xml')
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
resource_info = json.loads(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 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_resource_to_user(user, file_contents=wgt_file, packaged=True, raise_conflicts=True)
if not added:
raise Exception(_('Resource already exists %(resource_id)s') % {'resource_id': resource.local_uri_part})
return resource
else:
raise Exception('TODO')
def test_widget_code_cache(self):
client = Client()
client.login(username="******", password="******")
widget_id = {"vendor": "Wirecloud", "name": "test", "version": "0.1"}
file_contents = self.build_simple_wgt(
"template1.xml", other_files=("images/catalogue.png", "images/catalogue_iphone.png", "doc/index.html")
)
added, resource = install_resource_to_user(self.user, file_contents=file_contents)
self.assertTrue(added)
resource_pk = resource.pk
xhtml_pk = resource.widget.pk
# Cache widget code
response = client.get(reverse("wirecloud.widget_code_entry", kwargs=widget_id))
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=("images/catalogue.png", "images/catalogue_iphone.png", "doc/index.html"),
)
resource = install_resource_to_user(self.user, file_contents=file_contents)
response = client.get(reverse("wirecloud.widget_code_entry", kwargs=widget_id))
self.assertEqual(response.status_code, 200)
new_code = response.content
self.assertNotEqual(old_code, new_code)
def test_widget_code_cache(self):
template_uri = "http://example.com/path/widget.xml"
template = self.read_template('template1.xml')
client = Client()
client.login(username='******', password='******')
widget_id = {
'vendor': 'Wirecloud',
'name': 'test',
'version': '0.1',
}
self.network._servers['http']['example.com'].add_response('GET', '/path/widget.xml', {'content': template})
self.network._servers['http']['example.com'].add_response('GET', '/path/test.html', {'content': BASIC_HTML_GADGET_CODE})
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
resource_pk = resource.pk
xhtml_pk = resource.widget.pk
# Cache widget code
response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id))
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
self.network._servers['http']['example.com'].add_response('GET', '/path/test.html', {'content': 'cache'})
install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
response = client.get(reverse('wirecloud.widget_code_entry', kwargs=widget_id))
self.assertEqual(response.status_code, 200)
new_code = response.content
self.assertNotEqual(old_code, new_code)
def test_widget_with_minimal_info(self):
template_uri = "http://example.com/path/widget.xml"
template = self.read_template('template9.xml')
self.network._servers['http']['example.com'].add_response('GET', '/path/widget.xml', {'content': template})
self.network._servers['http']['example.com'].add_response('GET', '/path/test.html', {'content': BASIC_HTML_GADGET_CODE})
resource = install_resource_to_user(self.user, file_contents=template, templateURL=template_uri)
self.assertEqual(resource.vendor, 'Wirecloud')
self.assertEqual(resource.short_name, 'test')
self.assertEqual(resource.version, '0.1')
self.assertEqual(resource.mail, '*****@*****.**')
self.assertEqual(resource.public, False)
self.assertEqual(tuple(resource.users.values_list('username', flat=True)), (u'test',))
self.assertEqual(tuple(resource.groups.values_list('name', flat=True)), ())
def test_widget_with_minimal_info(self):
file_contents = self.build_simple_wgt('template9.xml')
added, resource = install_resource_to_user(self.user,
file_contents=file_contents)
self.assertTrue(added)
resource_info = json.loads(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 create(self, request):
status_code = 201
force_create = False
install_embedded_resources = False
templateURL = None
file_contents = None
content_type = get_content_type(request)[0]
if content_type == 'multipart/form-data':
force_create = request.POST.get('force_create', 'false').strip().lower() == 'true'
install_embedded_resources = request.POST.get('install_embedded_resources', 'false').strip().lower() == 'true'
if not 'file' 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 content_type == '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'
install_embedded_resources = request.GET.get('install_embedded_resources', 'false').strip().lower() == 'true'
else: # if content_type == '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)
templateURL = data.get('url')
market_endpoint = data.get('market_endpoint', None)
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:
downloaded_file = download_http_content(templateURL)
except:
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'))
try:
added, resource = install_resource_to_user(request.user, file_contents=file_contents, templateURL=templateURL)
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=six.text_type(details))
if install_embedded_resources:
info = {
'resource_details': resource.get_processed_info(request),
'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_resource_to_user(request.user, file_contents=extra_resource_contents, raise_conflicts=False)
if extra_resource_added:
info['extra_resources'].append(extra_resource.get_processed_info(request))
return HttpResponse(json.dumps(info), status=status_code, content_type='application/json; charset=UTF-8')
else:
return HttpResponse(json.dumps(resource.get_processed_info(request)), status=status_code, content_type='application/json; charset=UTF-8')
def test_template_translations(self):
file_contents = self.build_simple_wgt(
'template1.xml',
other_files=('images/catalogue.png', 'images/catalogue_iphone.png',
'doc/index.html'))
added, resource = install_resource_to_user(self.user,
file_contents=file_contents)
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_iphone.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': ''
}])
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
}])
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(self, request):
status_code = 201
force_create = False
install_embedded_resources = False
templateURL = None
file_contents = None
content_type = get_content_type(request)[0]
if content_type == 'multipart/form-data':
force_create = request.POST.get('force_create',
'false').strip().lower() == 'true'
public = request.POST.get('public',
'false').strip().lower() == 'true'
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 content_type == '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'
install_embedded_resources = request.GET.get(
'install_embedded_resources',
'false').strip().lower() == 'true'
else: # if content_type == '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'
templateURL = data.get('url')
market_endpoint = data.get('market_endpoint', None)
headers = data.get('headers', {})
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:
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:
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 and not request.user.is_superuser:
return build_error_response(
request, 403,
_('You are not allowed to make resources publicly available to all users'
))
try:
fix_dev_version(file_contents, request.user)
added, resource = install_resource_to_user(
request.user,
file_contents=file_contents,
templateURL=templateURL)
if not added and force_create:
return build_error_response(request, 409,
_('Resource already exists'))
elif not added:
status_code = 200
if public:
install_resource_to_all_users(executor_user=request.user,
file_contents=file_contents)
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=six.text_type(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)
if public:
extra_resource_added, extra_resource = install_resource_to_user(
request.user,
file_contents=extra_resource_contents,
raise_conflicts=False)
else:
extra_resource_added, extra_resource = install_resource_to_user(
request.user,
file_contents=extra_resource_contents,
raise_conflicts=False)
if extra_resource_added:
info['extra_resources'].append(
extra_resource.get_processed_info(
request,
url_pattern_name="wirecloud.showcase_media"))
return HttpResponse(json.dumps(info, sort_keys=True),
status=status_code,
content_type='application/json; charset=UTF-8')
else:
return 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')
def _handle(self, *args, **options):
if len(args) < 1:
raise CommandError(_('Wrong number of arguments'))
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 args:
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:
for user in users:
install_resource_to_user(user, file_contents=wgt_file)
for group in groups:
install_resource_to_group(group,
file_contents=wgt_file)
if public:
install_resource_to_all_users(file_contents=wgt_file)
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_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_resource_to_user(owner,
file_contents=extra_resource_contents)
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
