def test_lint_armada_manifest_no_groups(self): template_manifest = """ schema: armada/Manifest/v1 metadata: schema: metadata/Document/v1 name: example-manifest data: release_prefix: example """ document = yaml.safe_load_all(template_manifest) with self.assertRaises(Exception): lint.validate_armada_documents(document)
def invoke(self): if not self.ctx.obj.get('api', False): doc_data = ReferenceResolver.resolve_reference(self.locations) documents = list() for d in doc_data: documents.extend(list(yaml.safe_load_all(d.decode()))) manifest_obj = Manifest(documents).get_manifest() obj_check = validate_armada_object(manifest_obj) doc_check = validate_armada_documents(documents) try: if doc_check and obj_check: self.logger.info('Successfully validated: %s', self.locations) except Exception: raise Exception('Failed to validate: %s', self.locations) else: if len(self.locations) > 1: self.logger.error("Cannot specify multiple locations " "when using validate API.") return client = self.ctx.obj.get('CLIENT') resp = client.post_validate(self.locations[0]) if resp.get('code') == 200: self.logger.info('Successfully validated: %s', self.locations) else: self.logger.error("Failed to validate: %s", self.locations)
def on_post(self, req, resp): try: if req.content_type == 'application/json': self.logger.debug("Validating manifest based on reference.") json_body = self.req_json(req) if json_body.get('href', None): self.logger.debug( "Validating manifest from reference %s." % json_body.get('href')) data = ReferenceResolver.resolve_reference( json_body.get('href')) documents = list() for d in data: documents.extend(list(yaml.safe_load_all(d.decode()))) else: resp.status = falcon.HTTP_400 return else: manifest = self.req_yaml(req) documents = list(manifest) self.logger.debug("Validating set of %d documents." % len(documents)) result = validate_armada_documents(documents) resp.content_type = 'application/json' resp_body = { 'kind': 'Status', 'apiVersion': 'v1.0', 'metadata': {}, 'reason': 'Validation', 'details': { 'errorCount': 0, 'messageList': [] }, } if result: resp.status = falcon.HTTP_200 resp_body['status'] = 'Success' resp_body['message'] = 'Armada validations succeeded' resp_body['code'] = 200 else: resp.status = falcon.HTTP_400 resp_body['status'] = 'Failure' resp_body['message'] = 'Armada validations failed' resp_body['code'] = 400 resp_body['details']['errorCount'] = 1 resp_body['details']['messageList'].\ append(dict(message='Validation failed.', error=True)) resp.body = json.dumps(resp_body) except Exception as ex: err_message = 'Failed to validate Armada Manifest' self.logger.error(err_message, exc_info=ex) self.return_error(resp, falcon.HTTP_400, message=err_message)
def validateYaml(args): documents = yaml.safe_load_all(open(args.file).read()) manifest_obj = Manifest(documents).get_manifest() obj_check = validate_armada_object(manifest_obj) doc_check = validate_armada_documents(documents) try: if doc_check and obj_check: LOG.info('Successfully validated: %s', args.file) except Exception: raise Exception('Failed to validate: %s', args.file)
def pre_flight_ops(self): ''' Perform a series of checks and operations to ensure proper deployment ''' # Ensure tiller is available and manifest is valid if not self.tiller.tiller_status(): raise tiller_exceptions.TillerServicesUnavailableException() if not lint.validate_armada_documents(self.documents): raise lint_exceptions.InvalidManifestException() # Override manifest values if --set flag is used if self.overrides or self.values: self.documents = Override(self.documents, overrides=self.overrides, values=self.values).update_manifests() # Get config and validate self.config = self.get_armada_manifest() if not lint.validate_armada_object(self.config): raise lint_exceptions.InvalidArmadaObjectException() # Purge known releases that have failed and are in the current yaml prefix = self.config.get(const.KEYWORD_ARMADA).get( const.KEYWORD_PREFIX) failed_releases = self.get_releases_by_status(const.STATUS_FAILED) for release in failed_releases: for group in self.config.get(const.KEYWORD_ARMADA).get( const.KEYWORD_GROUPS): for ch in group.get(const.KEYWORD_CHARTS): ch_release_name = release_prefix( prefix, ch.get('chart').get('chart_name')) if release[0] == ch_release_name: LOG.info( 'Purging failed release %s ' 'before deployment', release[0]) self.tiller.uninstall_release(release[0]) # Clone the chart sources # # We only support a git source type right now, which can also # handle git:// local paths as well repos = {} for group in self.config.get(const.KEYWORD_ARMADA).get( const.KEYWORD_GROUPS): for ch in group.get(const.KEYWORD_CHARTS): self.tag_cloned_repo(ch, repos) for dep in ch.get('chart').get('dependencies'): self.tag_cloned_repo(dep, repos)
def update_manifests(self): if self.values: for value in self.values: merging_values = self._load_yaml_file(value) self.update_document(merging_values) if self.overrides: for override in self.overrides: new_value = override.split('=')[1] doc_path = override.split('=')[0].split(":") data_path = doc_path.pop().split('.') self.override_manifest_value(doc_path, data_path, new_value) try: lint.validate_armada_documents(self.documents) except Exception: raise override_exceptions.InvalidOverrideValueException( self.overrides) return self.documents
def on_post(self, req, resp): try: manifest = self.req_yaml(req) documents = list(manifest) message = { 'valid': validate_armada_documents(documents) } resp.status = falcon.HTTP_200 resp.body = json.dumps(message) resp.content_type = 'application/json' except Exception: err_message = 'Failed to validate Armada Manifest' self.error(req.context, err_message) self.return_error( resp, falcon.HTTP_400, message=err_message)
def on_post(self, req, resp): try: message = { 'valid': validate_armada_documents( list(yaml.safe_load_all(self.req_json(req)))) } if message.get('valid', False): resp.status = falcon.HTTP_200 else: resp.status = falcon.HTTP_400 resp.data = json.dumps(message) resp.content_type = 'application/json' except Exception: self.error(req.context, "Failed: Invalid Armada Manifest") self.return_error(resp, falcon.HTTP_400, message="Failed: Invalid Armada Manifest")
def invoke(self): if not self.ctx.obj.get('api', False): documents = yaml.safe_load_all(open(self.filename).read()) manifest_obj = Manifest(documents).get_manifest() obj_check = validate_armada_object(manifest_obj) doc_check = validate_armada_documents(documents) try: if doc_check and obj_check: self.logger.info('Successfully validated: %s', self.filename) except Exception: raise Exception('Failed to validate: %s', self.filename) else: client = self.ctx.obj.get('CLIENT') with open(self.filename, 'r') as f: resp = client.post_validate(f.read()) if resp.get('valid', False): self.logger.info('Successfully validated: %s', self.filename) else: self.logger.error("Failed to validate: %s", self.filename)
def test_lint_armada_yaml_pass(self): template = '{}/templates/valid_armada_document.yaml'.format( self.basepath) document = yaml.safe_load_all(open(template).read()) resp = lint.validate_armada_documents(document) self.assertTrue(resp)