def main(self, name, metadata_path):
self.setup_logger()
self.log.info("Registering new application using metadata at "
"%s" % metadata_path)
try:
with open(metadata_path) as m:
meta = m.read()
MetadataConfig.from_file(metadata_path)
except:
self.log.error("Invalid metadata in %s" % metadata_path)
return ExitCodes.command_error
self.api_connect(self.parent.config.server.login,
self.parent.config.server.apikey,
self.parent.config.server.url)
try:
self.api.application.post({'name': name,
'metadata': meta})
except SlumberHttpBaseException as e:
self.handle_error(e)
return ExitCodes.command_error
else:
self.log.info("Application '%s' created successfully" % name)
def clean_metadata(self):
metadata = self.cleaned_data['metadata']
try:
meta = metadata.read()
MetadataConfig.from_string(meta)
metadata = meta
except Exception as e:
raise forms.ValidationError(_("%s" % e))
return metadata
def main(self, name, metadata_path):
self.setup_logger()
self.log.info("Registering new application using metadata at "
"%s" % metadata_path)
meta = MetadataConfig.from_file(metadata_path)
self.api_connect(self.parent.config.server.login,
self.parent.config.server.apikey,
self.parent.config.server.url)
try:
resp = self.api.application.get(name=name)
except SlumberHttpBaseException as e:
self.handle_error(e)
else:
if not resp.get('objects'):
self.log.error("No such application registered: %s" % name)
return ExitCodes.notfound_error
app = resp['objects'][0]
try:
self.api.application(app['id']).patch(
{'metadata': meta.dump_string()})
except SlumberHttpBaseException as e:
self.handle_error(e)
else:
self.log.info("Application '%s' metadata updated "
"successfully" % name)
def metadata_detect(request):
return MetadataConfig.from_string('''
interpreter:
type: ruby
versions:
- 2.1.0
repository:
clone: echo "Cloned"
update: echo "Updated"
''')
def test_builder(builder_config):
metadata_path = os.path.join(os.path.dirname(__file__),
'mock_metadata.yml')
metadata = MetadataConfig.from_file(metadata_path)
builder = Builder(builder_config, metadata)
for build_result in builder.build_package():
continue
assert build_result.progress == 100
assert build_result.parent is None
assert build_result.interpreter_version == '1.8.7'
assert build_result.filename
assert build_result.checksum
assert build_result.bytes > 0
def obj_create(self, bundle, request=None, **kwargs):
# TODO use MongoCleanedDataFormValidation ??
metadata = bundle.data.get('metadata')
if not metadata:
raise exceptions.ValidationError(_('Missing metadata'))
try:
MetadataConfig.from_string(metadata)
except Exception as e:
raise exceptions.ValidationError(
_('Invalid metadata: {err}').format(err=e))
log.debug(_("Going to create new application for user "
"'{name}'").format(name=bundle.request.user.username))
try:
return super(MongoEngineResource, self).obj_create(
bundle, request=request, owner=bundle.request.user, **kwargs)
except mongoengine.ValidationError as e:
log.warning(_("Can't create new application, invalid data "
"payload: {msg}").format(msg=e.message))
raise exceptions.ValidationError(e.message)
except mongoengine.NotUniqueError as e:
log.warning(_("Can't create new application, duplicated fields: "
"{msg}").format(msg=e.message))
raise exceptions.ValidationError(e.message)
def test_supported_versions_major(interpreters_config):
metadata = MetadataConfig.from_string('''
interpreter:
type: ruby
versions:
- '2'
repository:
clone: echo "Cloned"
update: echo "Updated"
''')
valid = supported_versions(interpreters_config, metadata)
assert len(valid.keys()) == 2
assert '2.0' in valid
assert '2.1' in valid
def metadata_manual(request):
return MetadataConfig.from_string('''
interpreter:
type: ruby
versions:
- 2.1.0
repository:
clone: echo "Cloned"
update: echo "Updated"
revision:
id: revision id cmd
author: author cmd
date: date cmd
description: description cmd
changelog: changelog cmd
''')
def metadata_config(self):
if self.metadata:
return MetadataConfig.from_string(self.metadata)
return {}
