})
export class SearchTemplateComponent implements OnInit {
file: File;
- localBluePrintData: IBlueprint;
+ localBlueprintData: IBlueprint;
fileText: object[];
blueprintState: IBlueprintState;
bpState: Observable<IBlueprintState>;
entryDefinition: this.entryDefinition
}
this.store.dispatch(new SetBlueprintState(blueprintState))
-
+
}
async buildFileViewData(zip) {
download: '/controllerblueprint/download-blueprint/',
deploy: '/controllerblueprint/deploy-blueprint',
getMetaDate: '/controllerblueprint/meta-data/',
- countOfAllBluePrints: '/controllerblueprint/list/count',
+ countOfAllBlueprints: '/controllerblueprint/list/count',
getMetaDatePageable: '/controllerblueprint/metadata/paged',
getBlueprintByName: '/controllerblueprint/by-name/'
};
-import {BluePrintPage} from './model/BluePrint.model';
+import {BlueprintPage} from './model/Blueprint.model';
import {PackagesDashboardState} from './model/packages-dashboard.state';
-export function getBluePrintPageMock(): BluePrintPage {
+export function getBlueprintPageMock(): BlueprintPage {
return {
content: [
{
<ngx-ui-loader></ngx-ui-loader>
<div class="container">
<div class="creat-action-container">
- <button class="action-button save" (click)="editBluePrint()" [disabled]="!isSaveEnabled">
+ <button class="action-button save" (click)="editBlueprint()" [disabled]="!isSaveEnabled">
<i class="icon-save-sm" aria-hidden="true"></i>
<span>Save</span>
</button>
</div>
</div>
</div>
- <button type="button" class="btn btn-sm mb-2 btn-enrich" (click)="enrichBluePrint()">
+ <button type="button" class="btn btn-sm mb-2 btn-enrich" (click)="enrichBlueprint()">
<!-- data-toggle="modal" data-target="#enrichModal"-->
<i class="icon-enrich" aria-hidden="true"></i> Enrich
<div class="modal-footer">
<button type="button" class="btn btn-secondary" data-dismiss="modal">Cancel</button>
<button type="button" data-dismiss="modal" class="btn btn-primary btn-enrich"
- (click)="enrichBluePrint()">Enrich
+ (click)="enrichBlueprint()">Enrich
</button>
</div>
</div>
import { Component, ElementRef, OnDestroy, OnInit, ViewChild } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';
-import { BluePrintDetailModel } from '../model/BluePrint.detail.model';
+import { BlueprintDetailModel } from '../model/Blueprint.detail.model';
import { PackageCreationStore } from '../package-creation/package-creation.store';
import { FilesContent, FolderNodeElement } from '../package-creation/mapping-models/metadata/MetaDataTab.model';
import { MetadataTabComponent } from '../package-creation/metadata-tab/metadata-tab.component';
styleUrls: ['./configuration-dashboard.component.css'],
})
export class ConfigurationDashboardComponent extends ComponentCanDeactivate implements OnInit, OnDestroy {
- viewedPackage: BluePrintDetailModel = new BluePrintDetailModel();
+ viewedPackage: BlueprintDetailModel = new BlueprintDetailModel();
@ViewChild(MetadataTabComponent, { static: false })
metadataTabComponent: MetadataTabComponent;
public customActionName = '';
});
}
- private downloadCBAPackage(bluePrintDetailModels: BluePrintDetailModel) {
+ private downloadCBAPackage(bluePrintDetailModels: BlueprintDetailModel) {
this.configurationDashboardService.downloadResource(
this.viewedPackage.artifactName + '/' + this.viewedPackage.artifactVersion).subscribe(response => {
const blob = new Blob([response], { type: 'application/octet-stream' });
});
}
- editBluePrint() {
+ editBlueprint() {
this.ngxService.start();
this.configurationDashboardService.deletePackage(this.packageId).subscribe(res => {
this.formTreeData();
- this.saveBluePrintToDataBase();
+ this.saveBlueprintToDataBase();
});
}
this.metadataTabComponent.saveMetaDataToStore();
}
- saveBluePrintToDataBase() {
+ saveBlueprintToDataBase() {
this.create();
this.zipFile.generateAsync({ type: 'blob' })
.then(blob => {
this.cbaPackage.templateTopology.content = this.vlbDefinition.topology_template.content;
}
- enrichBluePrint() {
+ enrichBlueprint() {
this.ngxService.start();
this.packageCreationStore.addTopologyTemplate(this.cbaPackage.templateTopology);
this.formTreeData();
import { ApiService } from '../../../../common/core/services/api.typed.service';
import { BlueprintURLs } from '../../../../common/constants/app-constants';
import { Observable } from 'rxjs';
-import { BluePrintDetailModel } from '../model/BluePrint.detail.model';
+import { BlueprintDetailModel } from '../model/Blueprint.detail.model';
@Injectable({
providedIn: 'root'
})
export class ConfigurationDashboardService {
- constructor(private api: ApiService<BluePrintDetailModel>) {
+ constructor(private api: ApiService<BlueprintDetailModel>) {
}
- private getBluePrintModel(id: string): Observable<BluePrintDetailModel> {
+ private getBlueprintModel(id: string): Observable<BlueprintDetailModel> {
return this.api.getOne(BlueprintURLs.getOneBlueprint + '/' + id);
}
getPagedPackages(id: string) {
- return this.getBluePrintModel(id);
+ return this.getBlueprintModel(id);
}
public downloadResource(path: string) {
<div class="dropdown-text">Save</div>
<ul class="dropdown-content save-blueprint">
<li>
- <a (click)="saveBluePrint()"><i class="icon-save-sm" aria-hidden="true"></i> Save</a>
+ <a (click)="saveBlueprint()"><i class="icon-save-sm" aria-hidden="true"></i> Save</a>
</li>
<!-- <li>
- <a (click)="enrichBluePrint()"><i class="icon-enrich" aria-hidden="true"></i> Enrich</a>
+ <a (click)="enrichBlueprint()"><i class="icon-enrich" aria-hidden="true"></i> Enrich</a>
</li> -->
<li>
- <a (click)="enrichBluePrint()"><i class="fa fa-play-circle" aria-hidden="true"></i> Enrich & Deploy</a>
+ <a (click)="enrichBlueprint()"><i class="fa fa-play-circle" aria-hidden="true"></i> Enrich & Deploy</a>
</li>
</ul>
</div>
</div>
</div>
</div>
- <app-functions-attribute (saveEvent)="saveBluePrint()"></app-functions-attribute>
+ <app-functions-attribute (saveEvent)="saveBlueprint()"></app-functions-attribute>
</div>
</div>
</div>
import { FunctionsStore } from './functions.store';
import { Subject } from 'rxjs';
import { distinctUntilChanged, takeUntil } from 'rxjs/operators';
-import { BluePrintDetailModel } from '../model/BluePrint.detail.model';
+import { BlueprintDetailModel } from '../model/Blueprint.detail.model';
import { ActivatedRoute, Router } from '@angular/router';
import { DesignerService } from './designer.service';
import { FilesContent, FolderNodeElement } from '../package-creation/mapping-models/metadata/MetaDataTab.model';
controllerSideBar: boolean;
actionAttributesSideBar: boolean;
functionAttributeSidebar: boolean;
- viewedPackage: BluePrintDetailModel = new BluePrintDetailModel();
+ viewedPackage: BlueprintDetailModel = new BlueprintDetailModel();
customActionName: string;
showAction: boolean;
cl = 'editBar';
this.actionAttributesSideBar = !this.actionAttributesSideBar;
}
- publishBluePrint() {
+ publishBlueprint() {
this.create();
this.zipFile.generateAsync({ type: 'blob' })
.then(blob => {
this.toastService.error(error.message, 'Package error');
console.log(error);
}, () => {
- // this.deployBluePrint = false;
+ // this.deployBlueprint = false;
});
});
}
this.ngUnsubscribe.complete();
}
- saveBluePrint() {
+ saveBlueprint() {
this.ngxService.start();
FilesContent.clear();
let packageCreationModes: PackageCreationModes;
});
packageCreationModes.execute(this.cbaPackage, this.packageCreationUtils);
this.filesData.push(this.folder.TREE_DATA);
- this.saveBluePrintToDataBase();
+ this.saveBlueprintToDataBase();
}
- enrichBluePrint() {
+ enrichBlueprint() {
this.ngxService.start();
console.log('start enrich ------------');
this.packageCreationStore.addTopologyTemplate(this.cbaPackage.templateTopology);
}
- saveBluePrintToDataBase() {
+ saveBlueprintToDataBase() {
this.create();
this.zipFile.generateAsync({ type: 'blob' })
.then(blob => {
import { ApiService } from '../../../../common/core/services/api.typed.service';
import { ResourceDictionaryURLs, BlueprintURLs } from '../../../../common/constants/app-constants';
import { ModelType } from './model/ModelType.model';
-import { BluePrintDetailModel } from '../model/BluePrint.detail.model';
+import { BlueprintDetailModel } from '../model/Blueprint.detail.model';
@Injectable({
constructor(
private api: ApiService<ModelType>,
- private api2: ApiService<BluePrintDetailModel>
+ private api2: ApiService<BlueprintDetailModel>
) {
}
return this.api.get(ResourceDictionaryURLs.getResourceDictionary + '/' + modelDefinitionType);
}
- private getBluePrintModel(id: string): Observable<BluePrintDetailModel> {
+ private getBlueprintModel(id: string): Observable<BlueprintDetailModel> {
return this.api2.getOne(BlueprintURLs.getOneBlueprint + '/' + id);
}
getPagedPackages(id: string) {
- return this.getBluePrintModel(id);
+ return this.getBlueprintModel(id);
}
publishBlueprint(body: any | null, options?: any): Observable<any> {
import { PackageCreationUtils } from '../../package-creation/package-creation.utils';
import { RouterLink, Router, ActivatedRoute } from '@angular/router';
import { Subject } from 'rxjs';
-import { BluePrintDetailModel } from '../../model/BluePrint.detail.model';
+import { BlueprintDetailModel } from '../../model/Blueprint.detail.model';
import { viewClassName } from '@angular/compiler';
import { SourceViewService } from './source-view.service';
lang = 'json';
controllerSideBar: boolean;
ngUnsubscribe = new Subject();
- viewedPackage: BluePrintDetailModel = new BluePrintDetailModel();
+ viewedPackage: BlueprintDetailModel = new BlueprintDetailModel();
public customActionName = '';
cl = 'editBar';
packageId: string;
import {Injectable} from '@angular/core';
import {Observable} from 'rxjs';
import { ApiService } from 'src/app/common/core/services/api.typed.service';
-import { BluePrintDetailModel } from '../../model/BluePrint.detail.model';
+import { BlueprintDetailModel } from '../../model/Blueprint.detail.model';
import { ModelType } from '../model/ModelType.model';
import { ResourceDictionaryURLs, BlueprintURLs } from 'src/app/common/constants/app-constants';
})
export class SourceViewService {
- constructor(private api1: ApiService<BluePrintDetailModel>) {
+ constructor(private api1: ApiService<BlueprintDetailModel>) {
}
- private getBluePrintModel(id: string): Observable<BluePrintDetailModel> {
+ private getBlueprintModel(id: string): Observable<BlueprintDetailModel> {
return this.api1.getOne(BlueprintURLs.getOneBlueprint + '/' + id);
}
getPagedPackages(id: string) {
- return this.getBluePrintModel(id);
+ return this.getBlueprintModel(id);
}
}
*/
import {Page} from 'src/app/common/model/page';
-import {BlueprintModel} from './BluePrint.model';
+import {BlueprintModel} from './Blueprint.model';
-export class BluePrintDetailModel extends BlueprintModel {
+export class BlueprintDetailModel extends BlueprintModel {
blueprintModelContent: BlueprintModelContent;
}
}
/*
-export class BluePrintDetailModelContent {
- bluePrintDetailsModels: BluePrintDetailModel[];
+export class BlueprintDetailModelContent {
+ bluePrintDetailsModels: BlueprintDetailModel[];
}*/
tags: string;
}
-export class BluePrintPage extends Page<BlueprintModel> {
+export class BlueprintPage extends Page<BlueprintModel> {
}
*/
-import { BluePrintDetailModel } from './BluePrint.detail.model';
+import { BlueprintDetailModel } from './Blueprint.detail.model';
import { Mapping, Scripts, Template } from '../package-creation/mapping-models/CBAPacakge.model';
export class PackageDashboardState {
- configuration: BluePrintDetailModel;
+ configuration: BlueprintDetailModel;
public scripts: Scripts;
public templates: Template;
public mapping: Mapping;
============LICENSE_END============================================
*/
-import {BluePrintPage} from './BluePrint.model';
+import {BlueprintPage} from './Blueprint.model';
export class PackagesDashboardState {
- page: BluePrintPage;
- filteredPackages: BluePrintPage;
+ page: BlueprintPage;
+ filteredPackages: BlueprintPage;
command: string;
currentPage = 0;
totalPackages: number;
console.log('in validate');
console.log('in this.metaDataTab.name' + this.metaDataTab.name);
if (this.metaDataTab.name && this.metaDataTab.version) {
- this.packageCreationService.checkBluePrintNameAndVersion(this.metaDataTab.name, this.metaDataTab.version).then(element => {
+ this.packageCreationService.checkBlueprintNameAndVersion(this.metaDataTab.name, this.metaDataTab.version).then(element => {
if (element) {
this.errorMessage = 'Package name already exists with this version. Use different name or different version number.';
} else if (!this.metaDataTab.version.match(this.versionPattern)) {
import {PackageCreationUtils} from './package-creation.utils';
import {MetadataTabComponent} from './metadata-tab/metadata-tab.component';
import {DesignerStore} from '../designer/designer.store';
-import {BluePrintDetailModel} from '../model/BluePrint.detail.model';
+import {BlueprintDetailModel} from '../model/Blueprint.detail.model';
@Injectable({
providedIn: 'root'
this.packageCreationStore.changeMetaData(metaDataObject);
}
- public setMetaDataWithObject(metaDataObject: MetaDataTabModel, bluePrintDetailModel: BluePrintDetailModel) {
+ public setMetaDataWithObject(metaDataObject: MetaDataTabModel, bluePrintDetailModel: BlueprintDetailModel) {
metaDataObject.description = bluePrintDetailModel.artifactDescription;
this.packageCreationStore.changeMetaData(metaDataObject);
</header>
<div class="container-fluid body-container">
- <ngx-ui-loader></ngx-ui-loader>
+ <ngx-ui-loader></ngx-ui-loader>
<div class="container">
<div class="creat-action-container">
- <!-- <a class="action-button save" [hidden]="!isSaveEnabled" (click)="saveBluePrint()">
+ <!-- <a class="action-button save" [hidden]="!isSaveEnabled" (click)="saveBlueprint()">
<i class="icon-save-sm" aria-hidden="true"></i>
<span>Save</span>-->
- <button tourAnchor="packageSave" (click)="saveBluePrint()" [disabled]="!isSaveEnabled"
+ <button tourAnchor="packageSave" (click)="saveBlueprint()" [disabled]="!isSaveEnabled"
class="action-button save" aria-hidden="true"><i class="icon-save-sm" aria-hidden="true"></i>
<span>Save</span></button>
</div>
// this.tourService.goto(step);
}
- saveBluePrint() {
+ saveBlueprint() {
this.ngxService.start();
console.log(this.cbaPackage);
FilesContent.clear();
// this.cbaPackage.templateTopology.content = this.designerStore.state.sourceContent;
packageCreationModes.execute(this.cbaPackage, this.packageCreationUtils);
this.filesData.push(this.folder.TREE_DATA);
- this.saveBluePrintToDataBase();
+ this.saveBlueprintToDataBase();
}
- saveBluePrintToDataBase() {
+ saveBlueprintToDataBase() {
this.create();
this.zipFile.generateAsync({ type: 'blob' })
.then(blob => {
return this.api.post(BlueprintURLs.enrichandpublish, body, {responseType: 'text'});
}
- private deployBlue
Print(body: any | null, options?: any): Observable<any> {
+ private deployBlue
print(body: any | null, options?: any): Observable<any> {
return this.api.post(BlueprintURLs.deploy, body, {responseType: 'text'});
}
- async checkBluePrintNameAndVersion(name: string, version: string): Promise<boolean> {
- return await this.packagesListService.checkBluePrintIfItExists(name, version)
+ async checkBlueprintNameAndVersion(name: string, version: string): Promise<boolean> {
+ return await this.packagesListService.checkBlueprintIfItExists(name, version)
.then(bluePrintModelsResult => bluePrintModelsResult != null && bluePrintModelsResult.length > 0);
}
deploy(blob) {
const formData = this.getFormData(blob);
- return this.deployBluePrint(formData);
+ return this.deployBlueprint(formData);
}
private getFormData(blob) {
return this.api.getCustomized(BlueprintURLs.download + id, {responseType: 'blob'});
}
- public saveBluePrintToDataBase(): Observable<string> {
+ public saveBlueprintToDataBase(): Observable<string> {
this.formTreeData();
this.create();
const subject = new Subject<any>();
import {Observable} from 'rxjs';
import {ApiService} from '../../../common/core/services/api.typed.service';
import {BlueprintURLs} from '../../../common/constants/app-constants';
-import {BlueprintModel, BluePrintPage} from './model/BluePrint.model';
+import {BlueprintModel, BlueprintPage} from './model/Blueprint.model';
@Injectable({
packages: BlueprintModel[] = [];
private numberOfPackages: number;
- constructor(private api: ApiService<BluePrintPage>) {
+ constructor(private api: ApiService<BlueprintPage>) {
}
- getPagedPackages(pageNumber: number, pageSize: number, sortBy: string): Observable<BluePrintPage[]> {
+ getPagedPackages(pageNumber: number, pageSize: number, sortBy: string): Observable<BlueprintPage[]> {
const sortType = sortBy.includes('DATE') ? 'DESC' : 'ASC';
return this.api.get(BlueprintURLs.getPagedBlueprints, {
offset: pageNumber,
});
}
- async checkBluePrintIfItExists(name: string, version: string): Promise<BluePrintPage[]> {
+ async checkBlueprintIfItExists(name: string, version: string): Promise<BlueprintPage[]> {
return await this.api.get(BlueprintURLs.getBlueprintByName + '/' + name + '/version/' + version).toPromise();
}
import {Component, ElementRef, OnInit, QueryList, ViewChildren} from '@angular/core';
import {PackagesStore} from '../../packages.store';
-import {BlueprintModel, BluePrintPage} from '../../model/BluePrint.model';
+import {BlueprintModel, BlueprintPage} from '../../model/Blueprint.model';
@Component({
selector: 'app-filter-by-tags',
export class TagsFilteringComponent implements OnInit {
- page: BluePrintPage;
+ page: BlueprintPage;
tags: string[] = [];
viewedTags: string[] = [];
searchTag = '';
import { PackageListComponent } from './package-list.component';
import { PackagesStore } from '../../packages.store';
-import { getBluePrintPageMock } from '../../blueprint.page.mock';
+import { getBlueprintPageMock } from '../../blueprint.page.mock';
import { of } from 'rxjs';
import {PackagesDashboardState} from '../../model/packages-dashboard.state';
beforeEach(async(() => {
const dashBoard = new PackagesDashboardState();
- dashBoard.page = getBluePrintPageMock();
+ dashBoard.page = getBlueprintPageMock();
store = { state$: of(dashBoard) };
TestBed.configureTestingModule({
import {Component, OnInit} from '@angular/core';
-import {BlueprintModel} from '../../model/BluePrint.model';
+import {BlueprintModel} from '../../model/Blueprint.model';
import {PackagesStore} from '../../packages.store';
import {Router} from '@angular/router';
import {ConfigurationDashboardService} from '../../configuration-dashboard/configuration-dashboard.service';
import {PackagesStore} from '../../packages.store';
import {BrowserDynamicTestingModule, platformBrowserDynamicTesting} from '@angular/platform-browser-dynamic/testing';
import {PackagesDashboardState} from '../../model/packages-dashboard.state';
-import {getBluePrintPageMock} from '../../blueprint.page.mock';
+import {getBlueprintPageMock} from '../../blueprint.page.mock';
import {of} from 'rxjs';
import {By} from '@angular/platform-browser';
import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
import { PackagesApiService } from './packages-api.service';
import { of } from 'rxjs';
-import { BluePrintPage } from './model/BluePrint.model';
-import { getBluePrintPageMock } from './blueprint.page.mock';
+import { BlueprintPage } from './model/Blueprint.model';
+import { getBlueprintPageMock } from './blueprint.page.mock';
import { PackagesDashboardState } from './model/packages-dashboard.state';
describe('PackagesStore', () => {
// store: PackagesStore;
- const MOCK_BLUEPRINTS_PAGE: BluePrintPage = getBluePrintPageMock();
+ const MOCK_BLUEPRINTS_PAGE: BlueprintPage = getBlueprintPageMock();
let httpMock: HttpTestingController;
*/
import {Injectable} from '@angular/core';
-import {BluePrintPage} from './model/BluePrint.model';
+import {BlueprintPage} from './model/Blueprint.model';
import {Store} from '../../../common/core/stores/Store';
import {PackagesApiService} from './packages-api.service';
import {PackagesDashboardState} from './model/packages-dashboard.state';
export class PackagesStore extends Store<PackagesDashboardState> {
// TDOD fixed for now as there is no requirement to change it from UI
public pageSize = 15;
- private bluePrintContent: BluePrintPage = new BluePrintPage();
+ private bluePrintContent: BlueprintPage = new BlueprintPage();
constructor(
private packagesServiceList: PackagesApiService,
protected getPagedPackages(pageNumber: number, pageSize: number, sortBy: string = this.state.sortBy) {
this.packagesServiceList.getPagedPackages(pageNumber, pageSize, sortBy)
- .subscribe((pages: BluePrintPage[]) => {
+ .subscribe((pages: BlueprintPage[]) => {
this.setState({
...this.state,
page: pages[0],
private searchPagedPackages(keyWord: string, pageNumber: number, pageSize: number, sortBy: string = this.state.sortBy) {
this.packagesServiceList.getPagedPackagesByKeyWord(keyWord, pageNumber, pageSize, sortBy)
- .subscribe((pages: BluePrintPage[]) => {
+ .subscribe((pages: BlueprintPage[]) => {
this.setState({
...this.state,
page: pages[0],
private getPagedPackagesByTags(keyWord: string, currentPage1: number, pageSize: number, sortBy1: string, tagsSearchable: string[]) {
this.getPagedPackagesByKeyWordFilteredByTags(tagsSearchable)
- .subscribe((pages: BluePrintPage) => {
+ .subscribe((pages: BlueprintPage) => {
this.setState({
...this.state,
page: this.state.page,
const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
// The protoDescriptor object has the full package hierarchy
-const stub = new protoDescriptor.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService(
+const stub = new protoDescriptor.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService(
"" + processorApiConfig.grpc.host + ":" + processorApiConfig.grpc.port + "",
grpc.credentials.createInsecure());
const metadata = new grpc.Metadata();
metadata.add('Authorization', processorApiConfig.grpc.authToken);
-class BluePrintManagementServiceGrpcClient {
+class BlueprintManagementServiceGrpcClient {
async uploadBlueprint(filePath: string, actionName: string): Promise<any> {
}
}
-export const bluePrintManagementServiceGrpcClient = new BluePrintManagementServiceGrpcClient();
+export const bluePrintManagementServiceGrpcClient = new BlueprintManagementServiceGrpcClient();
authToken: process.env.API_BLUEPRINT_PROCESSOR_GRPC_AUTH_TOKEN || "Basic Y2NzZGthcHBzOmNjc2RrYXBwcw==",
bluePrintManagement: Object.freeze({
//this path is relative to 'dist' folder
- protoPath: __dirname + '../../../proto/BluePrintManagement.proto'
+ protoPath: __dirname + '../../../proto/BlueprintManagement.proto'
})
})
});
},
},
})
- async getOneBluePrint(@param.path.string('id') id: string) {
- return await this.bpservice.getOneBluePrint(id);
+ async getOneBlueprint(@param.path.string('id') id: string) {
+ return await this.bpservice.getOneBlueprint(id);
}
@del('/controllerblueprint/{id}', {
},
},
})
- async deleteBluePrint(@param.path.string('id') id: string) {
- return await this.bpservice.deleteBluePrint(id);
+ async deleteBlueprint(@param.path.string('id') id: string) {
+ return await this.bpservice.deleteBlueprint(id);
}
"responsePath": "$.*"
},
"functions": {
- "getOneBluePrint": ["id"]
+ "getOneBlueprint": ["id"]
}
},
"responsePath": "$.*"
},
"functions": {
- "deleteBluePrint": ["id"]
+ "deleteBlueprint": ["id"]
}
},
import { BlueprintDataSource } from '../datasources';
export interface BlueprintService {
- getOneBluePrint(id: string): any;
- deleteBluePrint(id: string): any;
+ getOneBlueprint(id: string): any;
+ deleteBlueprint(id: string): any;
getAllblueprints(): Promise<any>;
getBlueprintsByKeyword(keyword: string): Promise<any>;
getByTags(tags: string): Promise<JSON>;
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.RestLoggerService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ArchiveType
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.storedContentFromResolvedArtifactNB
import org.slf4j.LoggerFactory
// Check if definition exists
if (!api.hasDefinition()) {
- throw BluePrintProcessorException("K8s Config Template ($vfModuleInvariantID/$vfModuleUUID) - $k8sConfigTemplateName not found ")
+ throw BlueprintProcessorException("K8s Config Template ($vfModuleInvariantID/$vfModuleUUID) - $k8sConfigTemplateName not found ")
}
log.info("Config Template name: $k8sConfigTemplateName")
if (k8sRbProfileName.equals("")) {
- throw BluePrintProcessorException("K8s rb profile name is empty! Either define profile name to use or choose default")
+ throw BlueprintProcessorException("K8s rb profile name is empty! Either define profile name to use or choose default")
}
var configTemplate = K8sConfigTemplate()
}
catch (e: Exception) {
log.info("Caught exception trying to get the vnf Details!!")
- // throw BluePrintProcessorException("${e.message}")
+ // throw BlueprintProcessorException("${e.message}")
}
}
val profileFile = profileFilePath.toFile()
if (!profileFile.exists())
- throw BluePrintProcessorException("K8s Profile template file $profileFilePath does not exists")
+ throw BlueprintProcessorException("K8s Profile template file $profileFilePath does not exists")
return profileFilePath
}
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
log.info("Executing Recovery")
- bluePrintRuntimeService.getBluePrintError().addError("${runtimeException.message}")
+ bluePrintRuntimeService.getBlueprintError().addError("${runtimeException.message}")
}
fun modifyTemplate(configmapName: String, typOfVfmodule: String): String {
val templateFile = templateFilePath.toFile()
if (!templateFile.exists())
- throw BluePrintProcessorException("K8s Profile template file ${templateFilePath} does not exists")
+ throw BlueprintProcessorException("K8s Profile template file ${templateFilePath} does not exists")
log.info("Decompressing config template to ${destPath}")
- val decompressedProfile: File = BluePrintArchiveUtils.deCompress(templateFilePath.toFile(),
+ val decompressedProfile: File = BlueprintArchiveUtils.deCompress(templateFilePath.toFile(),
"${destPath}", ArchiveType.TarGz)
log.info("${templateFilePath.toString()} decompression completed")
log.info("Reading config template file: ${templateFilePath}")
if (!templateFile.exists())
- throw BluePrintProcessorException("config template file ${templateFilePath} does not exists")
+ throw BlueprintProcessorException("config template file ${templateFilePath} does not exists")
val tempMainPath: File = createTempDir("config-template-", "")
val tempConfigTemplatePath: File = createTempDir("conftemplate-", "", tempMainPath)
log.info("Decompressing profile to ${tempConfigTemplatePath.toString()}")
- val decompressedProfile2: File = BluePrintArchiveUtils.deCompress(templateFilePath.toFile(),
+ val decompressedProfile2: File = BlueprintArchiveUtils.deCompress(templateFilePath.toFile(),
"${tempConfigTemplatePath.toString()}", ArchiveType.TarGz)
log.info("${templateFilePath.toString()} decompression completed")
File(manifestFileName2).copyTo(File(destOverrideFile), true)
- if (!BluePrintArchiveUtils.compress(decompressedProfile2, templateFilePath.toFile(),
+ if (!BlueprintArchiveUtils.compress(decompressedProfile2, templateFilePath.toFile(),
ArchiveType.TarGz)) {
- throw BluePrintProcessorException("Profile compression has failed")
+ throw BlueprintProcessorException("Profile compression has failed")
}
log.info("${templateFilePath.toString()} compression completed")
return ""
} catch (e: Exception) {
log.info("Caught exception trying to get k8s instance details")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
return false
} catch (e: Exception) {
log.info("Caught exception trying to get k8s config trmplate definition")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
return false
} catch (e: Exception) {
log.info("Caught exception trying to get k8s config trmplate definition")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.info("Caught exception trying to create k8s config template ${profile.templateName} - updated")
- // throw BluePrintProcessorException("${e.message}")
+ // throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.info("Caught exception trying to upload k8s config template ${profile.templateName}")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.RestLoggerService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ArchiveType
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
import org.springframework.http.HttpHeaders
val api = K8sApi(k8sApiUsername, k8sApiPassword, baseK8sApiUrl, vfModuleModelInvariantUuid, vfModuleModelUuid)
if (!api.hasDefinition()) {
- throw BluePrintProcessorException("K8s RB Definition ($vfModuleModelInvariantUuid/$vfModuleModelUuid) not found ")
+ throw BlueprintProcessorException("K8s RB Definition ($vfModuleModelInvariantUuid/$vfModuleModelUuid) not found ")
}
log.info("k8s-rb-profile-name: $k8sRbProfileName")
if (k8sRbProfileName.equals("")) {
- throw BluePrintProcessorException("K8s rb profile name is empty! Either define profile name to use or choose default")
+ throw BlueprintProcessorException("K8s rb profile name is empty! Either define profile name to use or choose default")
}
if (k8sRbProfileName.equals("default") and api.hasProfile(k8sRbProfileName)) {
log.info("Using default profile - skipping upload")
val profileFile = profileFilePath.toFile()
if (!profileFile.exists())
- throw BluePrintProcessorException("K8s Profile template file $profileFilePath does not exists")
+ throw BlueprintProcessorException("K8s Profile template file $profileFilePath does not exists")
val tempMainPath: File = createTempDir("k8s-profile-", "")
val tempProfilePath: File = createTempDir("$k8sRbProfileName-", "", tempMainPath)
log.info("Decompressing profile to $tempProfilePath")
- val decompressedProfile: File = BluePrintArchiveUtils.deCompress(
+ val decompressedProfile: File = BlueprintArchiveUtils.deCompress(
profileFilePath.toFile(),
"$tempProfilePath",
ArchiveType.TarGz
File(tmpOverrideFile).copyTo(File(destOverrideFile), true)
profileFilePath = Paths.get(tempMainPath.toString().plus(File.separator).plus("template-profile.tar.gz"))
- if (!BluePrintArchiveUtils.compress(decompressedProfile, profileFilePath.toFile(), ArchiveType.TarGz)) {
- throw BluePrintProcessorException("Profile compression has failed")
+ if (!BlueprintArchiveUtils.compress(decompressedProfile, profileFilePath.toFile(), ArchiveType.TarGz)) {
+ throw BlueprintProcessorException("Profile compression has failed")
}
log.info("$profileFilePath compression completed")
return profileFilePath
val profileFile = profileFilePath.toFile()
if (!profileFile.exists())
- throw BluePrintProcessorException("K8s Profile template file $profileFilePath does not exists")
+ throw BlueprintProcessorException("K8s Profile template file $profileFilePath does not exists")
val success = File(destPath).mkdirs()
log.info("Decompressing profile to $destPath")
- val decompressedProfile: File = BluePrintArchiveUtils.deCompress(
+ val decompressedProfile: File = BlueprintArchiveUtils.deCompress(
profileFilePath.toFile(),
"$destPath",
ArchiveType.TarGz
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
log.info("Executing Recovery")
- bluePrintRuntimeService.getBluePrintError().addError("${runtimeException.message}")
+ bluePrintRuntimeService.getBlueprintError().addError("${runtimeException.message}")
}
inner class K8sApi(
return false
} catch (e: Exception) {
log.info("Caught exception trying to get k8s rb definition")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.info("Caught exception trying to get k8s rb profile")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.info("Caught exception trying to create k8s rb profile ${profile.profileName}")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.info("Caught exception trying to upload k8s rb profile ${profile.profileName}")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
import com.fasterxml.jackson.databind.node.ObjectNode
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import java.nio.file.Path
import org.springframework.http.HttpMethod
import org.onap.ccsdk.cds.blueprintsprocessor.rest.BasicAuthRestClientProperties
}
catch (e: Exception) {
log.info("Caught exception trying to get the vnf Details!!")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.info("Caught exception trying to create or update configuration ")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
import org.springframework.web.client.RestTemplate\r
import com.fasterxml.jackson.annotation.JsonIgnore\r
import com.fasterxml.jackson.annotation.JsonProperty\r
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException\r
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException\r
\r
open class ConfigDeploy : AbstractScriptComponentFunction() {\r
\r
print(resultOfGet)\r
} catch (e: Exception) {\r
log.info("Caught exception trying to connect to vLB!!")\r
- throw BluePrintProcessorException("${e.message}")\r
+ throw BlueprintProcessorException("${e.message}")\r
}\r
}\r
\r
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {\r
log.info("Executing Recovery")\r
- bluePrintRuntimeService.getBluePrintError().addError("${runtimeException.message}")\r
+ bluePrintRuntimeService.getBlueprintError().addError("${runtimeException.message}")\r
}\r
}\r
\r
import org.springframework.web.client.RestTemplate\r
import com.fasterxml.jackson.annotation.JsonIgnore\r
import com.fasterxml.jackson.annotation.JsonProperty\r
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException\r
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException\r
\r
open class HealthCheck : AbstractScriptComponentFunction() {\r
\r
// print(resultOfGet)\r
} catch (e: Exception) {\r
log.info("Caught exception trying to connect to vLB!!")\r
- throw BluePrintProcessorException("${e.message}")\r
+ throw BlueprintProcessorException("${e.message}")\r
}\r
}\r
\r
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {\r
log.info("Executing Recovery")\r
- bluePrintRuntimeService.getBluePrintError().addError("${runtimeException.message}")\r
+ bluePrintRuntimeService.getBlueprintError().addError("${runtimeException.message}")\r
}\r
}\r
\r
import org.springframework.web.client.RestTemplate\r
import com.fasterxml.jackson.annotation.JsonIgnore\r
import com.fasterxml.jackson.annotation.JsonProperty\r
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException\r
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException\r
\r
open class ConfigDeploy : AbstractScriptComponentFunction() {\r
\r
print(resultOfGet)\r
} catch (e: Exception) {\r
log.info("Caught exception trying to connect to vLB!!")\r
- throw BluePrintProcessorException("${e.message}")\r
+ throw BlueprintProcessorException("${e.message}")\r
}\r
}\r
\r
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {\r
log.info("Executing Recovery")\r
- bluePrintRuntimeService.getBluePrintError().addError("${runtimeException.message}")\r
+ bluePrintRuntimeService.getBlueprintError().addError("${runtimeException.message}")\r
}\r
}\r
\r
value = self.resolve_values_script(execution_request, self.value_to_resolve)
self.set_resource_data_value(execution_request, value)
else:
- raise BluePrintProcessorException("Error on resource assignment. Message = " + self.error_message)
+ raise BlueprintProcessorException("Error on resource assignment. Message = " + self.error_message)
return None
def recover(self, runtime_exception, execution_request):
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.nodeTypeComponentScriptExecutor
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.relationshipTemplateSshClient
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.relationshipTypeConnectsToSshClient
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.artifactTypeTemplateVelocity
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.getAttribute
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.nodeTypeComponent
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.relationshipTypeConnectsTo
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.AbstractBluePrintDefinitions
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.AbstractBlueprintDefinitions
-class CapabilityCliDefinitions : AbstractBluePrintDefinitions() {
+class CapabilityCliDefinitions : AbstractBlueprintDefinitions() {
override fun serviceTemplate(): ServiceTemplate {
return defaultServiceTemplate()
nodeTemplateComponentScriptExecutor(id = "check", description = "") {
definedOperation(description = "") {
inputs {
- type(BluePrintConstants.SCRIPT_KOTLIN)
+ type(BlueprintConstants.SCRIPT_KOTLIN)
scriptClassReference(Check::class)
}
outputs {
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.sshClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
open class Check : AbstractScriptComponentFunction() {
log.info("Executing process : ${executionRequest.payload}")
val data = requestPayloadActionProperty("data")?.first()
- ?: throw BluePrintProcessorException("Failed to load payload data properties.")
+ ?: throw BlueprintProcessorException("Failed to load payload data properties.")
log.info("Data : ${data.asJsonString()}")
log.info("Device Info :$deviceInformation")
// Get the Client Service
- val sshClientService = BluePrintDependencyService.sshClientService(deviceInformation)
+ val sshClientService = BlueprintDependencyService.sshClientService(deviceInformation)
log.info("Client service is ready")
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor.*
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.CapabilityResourceSource
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintScriptsService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintScriptsService
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
package cba.resource.audit
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.resourceDefinitions
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
const val SOURCE_SDNO = "SDN-O"
const val SOURCE_SDNC = "SDNC"
const val SOURCE_AAI = "AAI"
-val deviceResourceDefinitions = BluePrintTypes.resourceDefinitions {
+val deviceResourceDefinitions = BlueprintTypes.resourceDefinitions {
// Port Speed Definitions
resourceDefinition(name = "port-speed", description = "Port Speed") {
property(type = "string", required = true)
sources {
sourceCapability(id = SOURCE_SDNO, description = "SDN-O Source") {
definedProperties {
- type(BluePrintConstants.SCRIPT_KOTLIN)
+ type(BlueprintConstants.SCRIPT_KOTLIN)
scriptClassReference("cba.resource.audit.processor.PortSpeedRAProcessor")
keyDependencies(arrayListOf("device-id"))
}
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentScriptExecutor
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.nodeTemplateComponentScriptExecutor
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.nodeTypeComponentScriptExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.getAttribute
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.getNodeTemplateAttribute
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.nodeTypeComponent
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.AbstractBluePrintDefinitions
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.AbstractBlueprintDefinitions
-class ResourceAuditDefinitions : AbstractBluePrintDefinitions() {
+class ResourceAuditDefinitions : AbstractBlueprintDefinitions() {
override fun serviceTemplate(): ServiceTemplate {
return defaultServiceTemplate()
workflow(id = "config-collect", description = "Collect the configuration for Device") {
inputs {
- property(id = "device-id", type = BluePrintConstants.DATA_TYPE_STRING, required = true, description = "")
- property(id = "sources", type = BluePrintConstants.DATA_TYPE_LIST, required = true, description = "") {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ property(id = "device-id", type = BlueprintConstants.DATA_TYPE_STRING, required = true, description = "")
+ property(id = "sources", type = BlueprintConstants.DATA_TYPE_LIST, required = true, description = "") {
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
}
outputs {
- property(id = "response-data", required = true, type = BluePrintConstants.DATA_TYPE_STRING, description = "") {
+ property(id = "response-data", required = true, type = BlueprintConstants.DATA_TYPE_STRING, description = "") {
value(
getNodeTemplateAttribute(
nodeTemplateId = "config-collector",
)
)
}
- property(id = "status", required = true, type = BluePrintConstants.DATA_TYPE_STRING, description = "") {
- value(BluePrintConstants.STATUS_SUCCESS)
+ property(id = "status", required = true, type = BlueprintConstants.DATA_TYPE_STRING, description = "") {
+ value(BlueprintConstants.STATUS_SUCCESS)
}
}
step(id = "config-collector", target = "config-collector", description = "Collect the Configuration")
}
- val configCollectorComponent = BluePrintTypes.nodeTemplateComponentScriptExecutor(
+ val configCollectorComponent = BlueprintTypes.nodeTemplateComponentScriptExecutor(
id = "config-collector",
description = "Config collector component"
) {
definedOperation(description = "Config Collector Operation") {
inputs {
- type(BluePrintConstants.SCRIPT_KOTLIN)
+ type(BlueprintConstants.SCRIPT_KOTLIN)
scriptClassReference("cba.resource.audit.functions.ConfigCollector")
}
outputs {
nodeTemplate(configCollectorComponent)
}
- nodeType(BluePrintTypes.nodeTypeComponent())
- nodeType(BluePrintTypes.nodeTypeComponentScriptExecutor())
+ nodeType(BlueprintTypes.nodeTypeComponent())
+ nodeType(BlueprintTypes.nodeTypeComponentScriptExecutor())
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentScriptExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.jsonAsJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
}
// Set the Attributes
- setAttribute(ComponentScriptExecutor.ATTRIBUTE_STATUS, BluePrintConstants.STATUS_SUCCESS.asJsonPrimitive())
+ setAttribute(ComponentScriptExecutor.ATTRIBUTE_STATUS, BlueprintConstants.STATUS_SUCCESS.asJsonPrimitive())
setAttribute(
ComponentScriptExecutor.ATTRIBUTE_RESPONSE_DATA,
"""{
import org.onap.ccsdk.cds.blueprintsprocessor.functions.restconf.executor.restconfDeviceConfig
import org.onap.ccsdk.cds.blueprintsprocessor.functions.restconf.executor.restconfClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import com.fasterxml.jackson.databind.ObjectMapper
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService.WebClientResponse
// Un mount device
restconfUnMountDevice(webclientService, deviceID, "")
}
- } catch (bpe: BluePrintProcessorException) {
+ } catch (bpe: BlueprintProcessorException) {
log.error("Error looking up server identifier ", bpe)
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.rest.restClientService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintRetryException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintRetryException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
class RestconfSoftwareUpgrade : AbstractScriptComponentFunction() {
) {
return SoftwareUpgradeModel(
getDynamicProperties("resolution-key").asText(),
- BluePrintDependencyService.restClientService(RESTCONF_SERVER_IDENTIFIER),
+ BlueprintDependencyService.restClientService(RESTCONF_SERVER_IDENTIFIER),
properties.get("pnf-id").textValue(), properties.get("target-software-version").textValue(),
Action.getEnumFromActionName(executionRequest.actionIdentifiers.actionName)
)
} else {
- throw BluePrintException("Invalid parameters sent to CDS. Request parameters pnf-id or target-software-version missing")
+ throw BlueprintException("Invalid parameters sent to CDS. Request parameters pnf-id or target-software-version missing")
}
}
// Poll PNF for Activate action's progress
checkExecution(model)
} else {
- throw BluePrintRetryException("Software Download not completed for device(${model.deviceId}) to activate sw version: ${model.targetSwVersion}")
+ throw BlueprintRetryException("Software Download not completed for device(${model.deviceId}) to activate sw version: ${model.targetSwVersion}")
}
}
log.info("${model.action.name} is complete")
result.body
} else {
- throw BluePrintRetryException("Waiting for device(${model.deviceId}) to activate sw version ${model.targetSwVersion}")
+ throw BlueprintRetryException("Waiting for device(${model.deviceId}) to activate sw version ${model.targetSwVersion}")
}
}
model.client.retry<String>(10, 0, 1000, checkExecutionBlock)
for (value in values()) {
if (value.actionName == name) return value
}
- throw BluePrintException("Invalid Action sent to CDS")
+ throw BlueprintException("Invalid Action sent to CDS")
}
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.restconf.executor.restconfDeviceConfig
import org.onap.ccsdk.cds.blueprintsprocessor.functions.restconf.executor.restconfClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
class RestconfConfigDeploy : AbstractScriptComponentFunction() {
// Un mount device
restconfUnMountDevice(webclientService, deviceID, "")
}
- } catch (bpe: BluePrintProcessorException) {
+ } catch (bpe: BlueprintProcessorException) {
log.error("Error looking up server identifier ", bpe)
}
}
syntax = "proto3";
import "google/protobuf/struct.proto";
-import "BluePrintCommon.proto";
+import "BlueprintCommon.proto";
option java_multiple_files = true;
package org.onap.ccsdk.cds.controllerblueprints.management.api;
-message BluePrintUploadInput {
+message BlueprintUploadInput {
org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader commonHeader = 1;
FileChunk fileChunk = 2;
org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers actionIdentifiers = 3;
google.protobuf.Struct properties = 4;
}
-message BluePrintDownloadInput {
+message BlueprintDownloadInput {
org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader commonHeader = 1;
org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers actionIdentifiers = 2;
// Extra optional dynamic properties used to download.
google.protobuf.Struct properties = 3;
}
-message BluePrintRemoveInput {
+message BlueprintRemoveInput {
org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader commonHeader = 1;
org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers actionIdentifiers = 2;
// Extra optional dynamic properties used to remove.
google.protobuf.Struct properties = 3;
}
-message BluePrintBootstrapInput {
+message BlueprintBootstrapInput {
org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader commonHeader = 1;
bool loadCBA = 2;
bool loadModelType = 3;
bool loadResourceDictionary = 4;
}
-message BluePrintManagementOutput {
+message BlueprintManagementOutput {
org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader commonHeader = 1;
// Optional file chunk sent back to the client for Enrich and Download this is mandatory.
FileChunk fileChunk = 2;
message FileChunk {
bytes chunk = 1;
}
-// Values used in BluePrintDownloadInput/actionIdentifiers/action
+// Values used in BlueprintDownloadInput/actionIdentifiers/action
enum DownloadAction {
// Default is SEARCH the cba and download the cba
SEARCH = 0;
DEFAULT = 0;
}
-service BluePrintManagementService {
- rpc downloadBlueprint (BluePrintDownloadInput) returns (BluePrintManagementOutput);
- rpc uploadBlueprint (BluePrintUploadInput) returns (BluePrintManagementOutput);
- rpc removeBlueprint (BluePrintRemoveInput) returns (BluePrintManagementOutput);
- rpc bootstrapBlueprint (BluePrintBootstrapInput) returns (BluePrintManagementOutput);
+service BlueprintManagementService {
+ rpc downloadBlueprint (BlueprintDownloadInput) returns (BlueprintManagementOutput);
+ rpc uploadBlueprint (BlueprintUploadInput) returns (BlueprintManagementOutput);
+ rpc removeBlueprint (BlueprintRemoveInput) returns (BlueprintManagementOutput);
+ rpc bootstrapBlueprint (BlueprintBootstrapInput) returns (BlueprintManagementOutput);
}
syntax = "proto3";
import "google/protobuf/struct.proto";
-import "BluePrintCommon.proto";
+import "BlueprintCommon.proto";
option java_multiple_files = true;
package org.onap.ccsdk.cds.controllerblueprints.processing.api;
}
-service BluePrintProcessingService {
+service BlueprintProcessingService {
rpc process (stream ExecutionServiceInput) returns (stream ExecutionServiceOutput);
}
from org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils import \
ResourceAssignmentUtils
from org.onap.ccsdk.cds.controllerblueprints.core import \
- BluePrintProcessorException
+ BlueprintProcessorException
class AbstractRAProcessor(ResourceAssignmentProcessor):
else:
ResourceAssignmentUtils.Companion.setFailedResourceDataValue(
resource_assignment, "Fail to resolve value")
- except BluePrintProcessorException, err:
- raise BluePrintProcessorException(
+ except BlueprintProcessorException, err:
+ raise BlueprintProcessorException(
"Error on resource assignment. Message = " + err.message)
-class BluePrintRuntimeService:
+class BlueprintRuntimeService:
def __init__(self, bps):
self.bps = bps
"tags" : [ "Blueprint Model Catalog" ],\r
"summary" : "Download a Blueprint Model by ID",\r
"description" : "Gets the CBA of a blueprint model by its ID. Response can be saved to a file to download the CBA.",\r
- "operationId" : "BlueprintModelController_downloadBluePrint_GET.org.onap.ccsdk.cds.blueprintsprocessor.designer.api",\r
+ "operationId" : "BlueprintModelController_downloadBlueprint_GET.org.onap.ccsdk.cds.blueprintsprocessor.designer.api",\r
"produces" : [ "application/json" ],\r
"parameters" : [ {\r
"name" : "id",\r
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
log.info("Executing Recovery")
- bluePrintRuntimeService.getBluePrintError().addError("${runtimeException.message}")
+ bluePrintRuntimeService.getBlueprintError().addError("${runtimeException.message}")
}
}
.. code-block:: java
:caption: **Custom values for properties**
- -DappName=ControllerBluePrints
+ -DappName=ControllerBlueprints
-Dms_name=org.onap.ccsdk.apps.controllerblueprints
-DappVersion=1.0.0
-Dspring.config.location=opt/app/onap/config/
#### Example
```
-stub: BluePrintManagementServiceStub = BluePrintManagementServiceStub(channel)
+stub: BlueprintManagementServiceStub = BlueprintManagementServiceStub(channel)
with open(file_path, "rb") as cba_file:
- msg: BluePrintUploadInput = BluePrintUploadInput()
+ msg: BlueprintUploadInput = BlueprintUploadInput()
msg.actionIdentifiers.blueprintName = "Test"
msg.actionIdentifiers.blueprintVersion = "0.0.1"
msg.fileChunk.chunk = cba_file.read()
#### Example
```
-stub: BluePrintManagementServiceStub = BluePrintManagementServiceStub(channel)
-msg: BluePrintDownloadInput = BluePrintDownloadInput()
+stub: BlueprintManagementServiceStub = BlueprintManagementServiceStub(channel)
+msg: BlueprintDownloadInput = BlueprintDownloadInput()
msg.actionIdentifiers.blueprintName = "Test"
msg.actionIdentifiers.blueprintVersion = "0.0.1"
return stub.downloadBlueprint(msg)
#### Example
```
-stub: BluePrintManagementServiceStub = BluePrintManagementServiceStub(channel)
-msg: BluePrintRemoveInput = BluePrintRemoveInput()
+stub: BlueprintManagementServiceStub = BlueprintManagementServiceStub(channel)
+msg: BlueprintRemoveInput = BlueprintRemoveInput()
msg.actionIdentifiers.blueprintName = "Test"
msg.actionIdentifiers.blueprintVersion = "0.0.1"
return stub.removeBlueprint(msg)
from grpc import Channel, ChannelCredentials, insecure_channel, secure_channel, ssl_channel_credentials
-from proto.BluePrintManagement_pb2 import (
- BluePrintDownloadInput,
- BluePrintRemoveInput,
- BluePrintUploadInput,
- BluePrintManagementOutput,
+from proto.BlueprintManagement_pb2 import (
+ BlueprintDownloadInput,
+ BlueprintRemoveInput,
+ BlueprintUploadInput,
+ BlueprintManagementOutput,
)
-from proto.BluePrintManagement_pb2_grpc import BluePrintManagementServiceStub
+from proto.BlueprintManagement_pb2_grpc import BlueprintManagementServiceStub
logging.basicConfig(level=logging.DEBUG)
:param config: ConfigParser object with "client" section
"""
self.channel: Channel = channel
- self.stub: BluePrintManagementServiceStub = BluePrintManagementServiceStub(self.channel)
+ self.stub: BlueprintManagementServiceStub = BlueprintManagementServiceStub(self.channel)
self.config = config
- def upload(self) -> BluePrintManagementOutput:
+ def upload(self) -> BlueprintManagementOutput:
"""Prepare upload message and send it to server."""
logging.info("Call upload client method")
with open(self.config.get("client", "cba_file"), "rb") as cba_file:
- msg: BluePrintUploadInput = BluePrintUploadInput()
+ msg: BlueprintUploadInput = BlueprintUploadInput()
msg.actionIdentifiers.blueprintName = "Test"
msg.actionIdentifiers.blueprintVersion = "0.0.1"
msg.fileChunk.chunk = cba_file.read()
return self.stub.uploadBlueprint(msg)
- def download(self) -> BluePrintManagementOutput:
+ def download(self) -> BlueprintManagementOutput:
"""Prepare download message and send it to server."""
logging.info("Call download client method")
- msg: BluePrintDownloadInput = BluePrintDownloadInput()
+ msg: BlueprintDownloadInput = BlueprintDownloadInput()
msg.actionIdentifiers.blueprintName = "Test"
msg.actionIdentifiers.blueprintVersion = "0.0.1"
return self.stub.downloadBlueprint(msg)
- def remove(self) -> BluePrintManagementOutput:
+ def remove(self) -> BlueprintManagementOutput:
"""Prepare remove message and send it to server."""
logging.info("Call remove client method")
- msg: BluePrintRemoveInput = BluePrintRemoveInput()
+ msg: BlueprintRemoveInput = BlueprintRemoveInput()
msg.actionIdentifiers.blueprintName = "Test"
msg.actionIdentifiers.blueprintVersion = "0.0.1"
return self.stub.removeBlueprint(msg)
from manager.errors import ArtifactManagerError, InvalidRequestError
from manager.utils import Repository, RepositoryStrategy
from onaplogging.mdcContext import MDC
-from proto.BluePrintManagement_pb2 import (
- BluePrintDownloadInput,
- BluePrintManagementOutput,
- BluePrintRemoveInput,
- BluePrintUploadInput,
+from proto.BlueprintManagement_pb2 import (
+ BlueprintDownloadInput,
+ BlueprintManagementOutput,
+ BlueprintRemoveInput,
+ BlueprintUploadInput,
)
-from proto.BluePrintManagement_pb2_grpc import BluePrintManagementServiceServicer
+from proto.BlueprintManagement_pb2_grpc import BlueprintManagementServiceServicer
MDC_DATETIME_FORMAT = r"%Y-%m-%dT%H:%M:%S.%f%z"
COMMON_HEADER_DATETIME_FORMAT = r"%Y-%m-%dT%H:%M:%S.%fZ"
@wraps(func)
def _decorator(
servicer: "ArtifactManagerServicer",
- request: Union[BluePrintDownloadInput, BluePrintRemoveInput, BluePrintUploadInput],
+ request: Union[BlueprintDownloadInput, BlueprintRemoveInput, BlueprintUploadInput],
context: ServicerContext,
- ) -> BluePrintManagementOutput:
+ ) -> BlueprintManagementOutput:
if not all([request.actionIdentifiers.blueprintName, request.actionIdentifiers.blueprintVersion]):
- raise InvalidRequestError("Request has to have set both BluePrint name and version")
- output: BluePrintManagementOutput = func(servicer, request, context)
+ raise InvalidRequestError("Request has to have set both Blueprint name and version")
+ output: BlueprintManagementOutput = func(servicer, request, context)
# Set same values for every handler
output.commonHeader.CopyFrom(request.commonHeader)
output.commonHeader.timestamp = datetime.utcnow().strftime(COMMON_HEADER_DATETIME_FORMAT)
@wraps(func)
def _handler(
servicer: "ArtifactManagerServicer",
- request: Union[BluePrintDownloadInput, BluePrintRemoveInput, BluePrintUploadInput],
+ request: Union[BlueprintDownloadInput, BlueprintRemoveInput, BlueprintUploadInput],
context: ServicerContext,
- ) -> BluePrintManagementOutput:
+ ) -> BlueprintManagementOutput:
try:
- output: BluePrintManagementOutput = func(servicer, request, context)
+ output: BlueprintManagementOutput = func(servicer, request, context)
output.status.code = 200
output.status.message = "success"
except ArtifactManagerError as error:
# Every ArtifactManagerError based exception has status_code paramenter
# which has to be set in output. Use also exception's message to
# set errorMessage of the output.
- output: BluePrintManagementOutput = BluePrintManagementOutput()
+ output: BlueprintManagementOutput = BlueprintManagementOutput()
output.status.code = error.status_code
output.status.message = "failure"
output.status.errorMessage = str(error.message)
@wraps(func)
def _decorator(
servicer: "ArtifactManagerServicer",
- request: Union[BluePrintDownloadInput, BluePrintRemoveInput, BluePrintUploadInput],
+ request: Union[BlueprintDownloadInput, BlueprintRemoveInput, BlueprintUploadInput],
context: ServicerContext,
- ) -> BluePrintManagementOutput:
+ ) -> BlueprintManagementOutput:
MDC.put("RequestID", request.commonHeader.requestId)
MDC.put("InvocationID", request.commonHeader.subRequestId)
MDC.put("ServiceName", servicer.__class__.__name__)
MDC.put("TargetServiceName", func.__name__)
MDC.put("Server", socket.getfqdn())
- output: BluePrintManagementOutput = func(servicer, request, context)
+ output: BlueprintManagementOutput = func(servicer, request, context)
MDC.clear()
return output
return _decorator
-class ArtifactManagerServicer(BluePrintManagementServiceServicer):
+class ArtifactManagerServicer(BlueprintManagementServiceServicer):
"""ArtifactManagerServer class.
Implements methods defined in proto files to manage artifacts repository.
@prepare_logging_context
@translate_exception_to_response
@fill_common_header
- def downloadBlueprint(self, request: BluePrintDownloadInput, context: ServicerContext) -> BluePrintManagementOutput:
+ def downloadBlueprint(self, request: BlueprintDownloadInput, context: ServicerContext) -> BlueprintManagementOutput:
"""Download blueprint file request method.
Currently it only logs when is called and all base class method.
- :param request: BluePrintDownloadInput
+ :param request: BlueprintDownloadInput
:param context: ServicerContext
- :return: BluePrintManagementOutput
+ :return: BlueprintManagementOutput
"""
- output: BluePrintManagementOutput = BluePrintManagementOutput()
+ output: BlueprintManagementOutput = BlueprintManagementOutput()
output.fileChunk.chunk = self.repository.download_blueprint(
request.actionIdentifiers.blueprintName, request.actionIdentifiers.blueprintVersion
)
@prepare_logging_context
@translate_exception_to_response
@fill_common_header
- def uploadBlueprint(self, request: BluePrintUploadInput, context: ServicerContext) -> BluePrintManagementOutput:
+ def uploadBlueprint(self, request: BlueprintUploadInput, context: ServicerContext) -> BlueprintManagementOutput:
"""Upload blueprint file request method.
Currently it only logs when is called and all base class method.
- :param request: BluePrintUploadInput
+ :param request: BlueprintUploadInput
:param context: ServicerContext
- :return: BluePrintManagementOutput
+ :return: BlueprintManagementOutput
"""
self.repository.upload_blueprint(
request.fileChunk.chunk, request.actionIdentifiers.blueprintName, request.actionIdentifiers.blueprintVersion
),
extra={"mdc": MDC.result()},
)
- return BluePrintManagementOutput()
+ return BlueprintManagementOutput()
@prepare_logging_context
@translate_exception_to_response
@fill_common_header
- def removeBlueprint(self, request: BluePrintRemoveInput, context: ServicerContext) -> BluePrintManagementOutput:
+ def removeBlueprint(self, request: BlueprintRemoveInput, context: ServicerContext) -> BlueprintManagementOutput:
"""Remove blueprint file request method.
Currently it only logs when is called and all base class method.
- :param request: BluePrintRemoveInput
+ :param request: BlueprintRemoveInput
:param context: ServicerContext
- :return: BluePrintManagementOutput
+ :return: BlueprintManagementOutput
"""
self.repository.remove_blueprint(
request.actionIdentifiers.blueprintName, request.actionIdentifiers.blueprintVersion
),
extra={"mdc": MDC.result()},
)
- return BluePrintManagementOutput()
+ return BlueprintManagementOutput()
from grpc import server as grpc_server
from manager.configuration import config
from manager.servicer import ArtifactManagerServicer
-from proto.BluePrintManagement_pb2_grpc import add_BluePrintManagementServiceServicer_to_server
+from proto.BlueprintManagement_pb2_grpc import add_BlueprintManagementServiceServicer_to_server
@click.command()
max_workers: int = int(config["artifactManagerServer"]["maxWorkers"])
server: grpc_server = grpc_server(ThreadPoolExecutor(max_workers=max_workers))
- add_BluePrintManagementServiceServicer_to_server(ArtifactManagerServicer(), server)
+ add_BlueprintManagementServiceServicer_to_server(ArtifactManagerServicer(), server)
port_number: int = int(config["artifactManagerServer"]["port"])
server.add_insecure_port(f"[::]:{port_number}")
import manager.utils
from manager.servicer import ArtifactManagerServicer
-from proto.BluePrintCommon_pb2 import ActionIdentifiers, CommonHeader
-from proto.BluePrintManagement_pb2 import (
- BluePrintDownloadInput,
- BluePrintManagementOutput,
- BluePrintRemoveInput,
- BluePrintUploadInput,
+from proto.BlueprintCommon_pb2 import ActionIdentifiers, CommonHeader
+from proto.BlueprintManagement_pb2 import (
+ BlueprintDownloadInput,
+ BlueprintManagementOutput,
+ BlueprintRemoveInput,
+ BlueprintUploadInput,
FileChunk,
)
-from proto.BluePrintManagement_pb2_grpc import (
- BluePrintManagementServiceStub,
- add_BluePrintManagementServiceServicer_to_server,
+from proto.BlueprintManagement_pb2_grpc import (
+ BlueprintManagementServiceStub,
+ add_BlueprintManagementServiceServicer_to_server,
)
from pytest import fixture
@fixture(scope="module")
def grpc_add_to_server():
"""pytest-grpcio required function."""
- return add_BluePrintManagementServiceServicer_to_server
+ return add_BlueprintManagementServiceServicer_to_server
@fixture(scope="module")
@fixture(scope="module") # noqa
def grpc_stub_cls(grpc_channel):
"""pytest-grpcio required function."""
- return BluePrintManagementServiceStub
+ return BlueprintManagementServiceStub
def test_servicer_upload_handler_header_failure(grpc_stub):
"""Test servicer upload handler."""
- request: BluePrintUploadInput = BluePrintUploadInput()
- output: BluePrintManagementOutput = grpc_stub.uploadBlueprint(request)
+ request: BlueprintUploadInput = BlueprintUploadInput()
+ output: BlueprintManagementOutput = grpc_stub.uploadBlueprint(request)
assert output.status.code == 500
assert output.status.message == "failure"
- assert output.status.errorMessage == "Request has to have set both BluePrint name and version"
+ assert output.status.errorMessage == "Request has to have set both Blueprint name and version"
def test_servicer_download_handler_header_failure(grpc_stub):
"""Test servicer download handler."""
- request: BluePrintDownloadInput = BluePrintDownloadInput()
- output: BluePrintManagementOutput = grpc_stub.downloadBlueprint(request)
+ request: BlueprintDownloadInput = BlueprintDownloadInput()
+ output: BlueprintManagementOutput = grpc_stub.downloadBlueprint(request)
assert output.status.code == 500
assert output.status.message == "failure"
- assert output.status.errorMessage == "Request has to have set both BluePrint name and version"
+ assert output.status.errorMessage == "Request has to have set both Blueprint name and version"
def test_servicer_remove_handler_header_failure(grpc_stub):
"""Test servicer remove handler."""
- request: BluePrintRemoveInput = BluePrintRemoveInput()
- output: BluePrintManagementOutput = grpc_stub.removeBlueprint(request)
+ request: BlueprintRemoveInput = BlueprintRemoveInput()
+ output: BlueprintManagementOutput = grpc_stub.removeBlueprint(request)
assert output.status.code == 500
assert output.status.message == "failure"
- assert output.status.errorMessage == "Request has to have set both BluePrint name and version"
+ assert output.status.errorMessage == "Request has to have set both Blueprint name and version"
def test_servicer_upload_handler_failure(grpc_stub):
action_identifiers: ActionIdentifiers = ActionIdentifiers()
action_identifiers.blueprintName = "sample-cba"
action_identifiers.blueprintVersion = "1.0.0"
- request: BluePrintUploadInput = BluePrintUploadInput(actionIdentifiers=action_identifiers)
- output: BluePrintManagementOutput = grpc_stub.uploadBlueprint(request)
+ request: BlueprintUploadInput = BlueprintUploadInput(actionIdentifiers=action_identifiers)
+ output: BlueprintManagementOutput = grpc_stub.uploadBlueprint(request)
assert output.status.code == 500
assert output.status.message == "failure"
assert output.status.errorMessage == "Invalid request"
action_identifiers: ActionIdentifiers = ActionIdentifiers()
action_identifiers.blueprintName = "sample-cba"
action_identifiers.blueprintVersion = "2.0.0"
- request: BluePrintDownloadInput = BluePrintDownloadInput(actionIdentifiers=action_identifiers)
- output: BluePrintManagementOutput = grpc_stub.downloadBlueprint(request)
+ request: BlueprintDownloadInput = BlueprintDownloadInput(actionIdentifiers=action_identifiers)
+ output: BlueprintManagementOutput = grpc_stub.downloadBlueprint(request)
assert output.status.code == 500
assert output.status.message == "failure"
assert output.status.errorMessage == "Artifact not found"
action_identifiers: ActionIdentifiers = ActionIdentifiers()
action_identifiers.blueprintName = "sample-cba"
action_identifiers.blueprintVersion = "1.0.0"
- request: BluePrintRemoveInput = BluePrintRemoveInput(actionIdentifiers=action_identifiers)
- output: BluePrintManagementOutput = grpc_stub.removeBlueprint(request)
+ request: BlueprintRemoveInput = BlueprintRemoveInput(actionIdentifiers=action_identifiers)
+ output: BlueprintManagementOutput = grpc_stub.removeBlueprint(request)
assert output.status.code == 500
assert output.status.message == "failure"
assert output.status.errorMessage == "Artifact not found"
# fmt: off
with patch.object(os, "makedirs", return_value=None), \
patch.object(manager.utils, 'ZipFile', return_value=MockZipFile()):
- request: BluePrintUploadInput = BluePrintUploadInput(
+ request: BlueprintUploadInput = BlueprintUploadInput(
commonHeader=header, fileChunk=file_chunk, actionIdentifiers=action_identifiers
)
- output: BluePrintManagementOutput = grpc_stub.uploadBlueprint(request)
+ output: BlueprintManagementOutput = grpc_stub.uploadBlueprint(request)
# fmt: on
assert output.status.code == 200
assert output.status.message == "success"
action_identifiers.actionName = "SampleScript"
with patch.object(os.path, "exists", return_value=True):
- request: BluePrintDownloadInput = BluePrintDownloadInput(
+ request: BlueprintDownloadInput = BlueprintDownloadInput(
commonHeader=header, actionIdentifiers=action_identifiers
)
- output: BluePrintManagementOutput = grpc_stub.downloadBlueprint(request)
+ output: BlueprintManagementOutput = grpc_stub.downloadBlueprint(request)
assert output.status.code == 200
assert output.status.message == "success"
assert output.fileChunk.chunk == ZIP_FILE_BINARY
action_identifiers.actionName = "SampleScript"
with patch.object(shutil, "rmtree", return_value=None) as mock_rmtree:
- request: BluePrintRemoveInput = BluePrintRemoveInput(commonHeader=header, actionIdentifiers=action_identifiers)
- output: BluePrintManagementOutput = grpc_stub.removeBlueprint(request)
+ request: BlueprintRemoveInput = BlueprintRemoveInput(commonHeader=header, actionIdentifiers=action_identifiers)
+ output: BlueprintManagementOutput = grpc_stub.removeBlueprint(request)
assert output.status.code == 200
assert output.status.message == "success"
package org.onap.ccsdk.cds.blueprintsprocessor
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.PrimaryDatabaseConfiguration
import org.springframework.context.annotation.Bean
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = [
"org.onap.ccsdk.cds.controllerblueprints", "org.onap.ccsdk.cds.blueprintsprocessor",
package org.onap.ccsdk.cds.blueprintsprocessor
import io.grpc.ServerBuilder
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.BluePrintManagementGRPCHandler
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.BlueprintManagementGRPCHandler
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.interceptor.GrpcServerLoggingInterceptor
import org.onap.ccsdk.cds.blueprintsprocessor.security.BasicAuthServerInterceptor
-import org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api.BluePrintProcessingGRPCHandler
+import org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api.BlueprintProcessingGRPCHandler
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
@ConditionalOnProperty(name = ["blueprintsprocessor.grpcEnable"], havingValue = "true")
@Component
open class BlueprintGRPCServer(
- private val bluePrintProcessingGRPCHandler: BluePrintProcessingGRPCHandler,
- private val bluePrintManagementGRPCHandler: BluePrintManagementGRPCHandler,
+ private val bluePrintProcessingGRPCHandler: BlueprintProcessingGRPCHandler,
+ private val bluePrintManagementGRPCHandler: BlueprintManagementGRPCHandler,
private val authInterceptor: BasicAuthServerInterceptor
) :
ApplicationListener<ContextRefreshedEvent> {
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterInfo
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ClusterUtils
import org.springframework.boot.context.event.ApplicationReadyEvent
* if CLUSTER_ENABLED is present, then it will try to create cluster.
*/
@Component
-open class BluePrintProcessorCluster(private val bluePrintClusterService: BluePrintClusterService) {
+open class BlueprintProcessorCluster(private val bluePrintClusterService: BlueprintClusterService) {
- private val log = logger(BluePrintProcessorCluster::class)
+ private val log = logger(BlueprintProcessorCluster::class)
@EventListener(ApplicationReadyEvent::class)
fun startAndJoinCluster() = GlobalScope.launch {
- if (BluePrintConstants.CLUSTER_ENABLED) {
+ if (BlueprintConstants.CLUSTER_ENABLED) {
val clusterId = ClusterUtils.clusterId()
val nodeId = ClusterUtils.clusterNodeId()
val joinAsClient =
- (System.getenv(BluePrintConstants.PROPERTY_CLUSTER_JOIN_AS_CLIENT) ?: "false").toBoolean()
+ (System.getenv(BlueprintConstants.PROPERTY_CLUSTER_JOIN_AS_CLIENT) ?: "false").toBoolean()
- val clusterConfigFile = System.getenv(BluePrintConstants.PROPERTY_CLUSTER_CONFIG_FILE)
+ val clusterConfigFile = System.getenv(BlueprintConstants.PROPERTY_CLUSTER_CONFIG_FILE)
val properties = Properties()
properties["hazelcast.logging.type"] = "slf4j"
import kotlinx.coroutines.runBlocking
import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.domain.HealthApiResponse
import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.domain.HealthCheckStatus
-import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.service.health.BluePrintProcessorHealthCheck
+import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.service.health.BlueprintProcessorHealthCheck
import org.slf4j.LoggerFactory
import org.springframework.boot.actuate.health.AbstractHealthIndicator
import org.springframework.boot.actuate.health.Health
import org.springframework.stereotype.Component
/**
- * Health Indicator for BluePrintProcessor.
+ * Health Indicator for BlueprintProcessor.
* @author Shaaban Ebrahim
* @version 1.0
*/
@Component
-open class BluePrintCustomIndicator(private val bluePrintProcessorHealthCheck: BluePrintProcessorHealthCheck) :
+open class BlueprintCustomIndicator(private val bluePrintProcessorHealthCheck: BlueprintProcessorHealthCheck) :
AbstractHealthIndicator() {
- private var logger = LoggerFactory.getLogger(BluePrintCustomIndicator::class.java)
+ private var logger = LoggerFactory.getLogger(BlueprintCustomIndicator::class.java)
@Throws(Exception::class)
override fun doHealthCheck(builder: Health.Builder) {
import org.hamcrest.MatcherAssert.assertThat
import org.mockito.Answers
import org.mockito.verification.VerificationMode
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService.WebClientResponse
import org.onap.ccsdk.cds.blueprintsprocessor.uat.logging.LogColor.COLOR_MOCKITO
@Component
class UatExecutor(
private val environment: ConfigurableEnvironment,
- private val restClientFactory: BluePrintRestLibPropertyService,
+ private val restClientFactory: BlueprintRestLibPropertyService,
private val mapper: ObjectMapper
) {
return "Basic " + Base64Utils.encodeToString("$username:$plainPassword".toByteArray())
}
- private class MockPreInterceptor : BluePrintRestLibPropertyService.PreInterceptor {
+ private class MockPreInterceptor : BlueprintRestLibPropertyService.PreInterceptor {
private val mocks = ConcurrentHashMap<String, BlueprintWebClientService>()
}
}
- private class SpyPostInterceptor(private val mapper: ObjectMapper) : BluePrintRestLibPropertyService.PostInterceptor {
+ private class SpyPostInterceptor(private val mapper: ObjectMapper) : BlueprintRestLibPropertyService.PostInterceptor {
private val spies = ConcurrentHashMap<String, SpyService>()
import org.onap.ccsdk.cds.blueprintsprocessor.uat.logging.LogColor.COLOR_SERVICES
import org.onap.ccsdk.cds.blueprintsprocessor.uat.logging.LogColor.resetContextColor
import org.onap.ccsdk.cds.blueprintsprocessor.uat.logging.LogColor.setContextColor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.UAT_SPECIFICATION_FILE
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.UAT_SPECIFICATION_FILE
import org.springframework.context.annotation.Profile
import org.springframework.http.HttpStatus
import org.springframework.http.MediaType
blueprintsprocessor.blueprintWorkingPath=blueprints/work
# Controller Blueprint Load Configurations
-blueprintsprocessor.loadBluePrintPaths=./../../../components/model-catalog/blueprint-model/service-blueprint
+blueprintsprocessor.loadBlueprintPaths=./../../../components/model-catalog/blueprint-model/service-blueprint
blueprintsprocessor.loadModeTypePaths=./../../../components/model-catalog/definition-type/starter-type
blueprintsprocessor.loadResourceDictionaryPaths=./../../../components/model-catalog/resource-dictionary/starter-dictionary
-appName: ControllerBluePrints
+appName: ControllerBlueprints
appVersion: 1.0.0
blueprints:
processor:
blueprintsprocessor.blueprintWorkingPath=/opt/app/onap/blueprints/working
# Controller Blueprint Load Configurations
-blueprintsprocessor.loadBluePrintPaths=/opt/app/onap/model-catalog/blueprint-model
+blueprintsprocessor.loadBlueprintPaths=/opt/app/onap/model-catalog/blueprint-model
blueprintsprocessor.loadModeTypePaths=/opt/app/onap/model-catalog/definition-type
blueprintsprocessor.loadResourceDictionaryPaths=/opt/app/onap/model-catalog/resource-dictionary
import org.junit.runners.Parameterized
import org.onap.ccsdk.cds.blueprintsprocessor.uat.utils.ExtendedTemporaryFolder
import org.onap.ccsdk.cds.blueprintsprocessor.uat.utils.UatExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.UAT_SPECIFICATION_FILE
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils.Companion.compressToBytes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.UAT_SPECIFICATION_FILE
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils.Companion.compressToBytes
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.junit4.rules.SpringClassRule
import org.springframework.test.context.junit4.rules.SpringMethodRule
import org.onap.ccsdk.cds.blueprintsprocessor.uat.utils.ServiceDefinition
import org.onap.ccsdk.cds.blueprintsprocessor.uat.utils.TestSecuritySettings
import org.onap.ccsdk.cds.blueprintsprocessor.uat.utils.UatDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.UAT_SPECIFICATION_FILE
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils.Companion.compressToBytes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.UAT_SPECIFICATION_FILE
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils.Companion.compressToBytes
import org.skyscreamer.jsonassert.JSONAssert
import org.skyscreamer.jsonassert.JSONCompareMode
import org.springframework.beans.factory.annotation.Autowired
# Controller Blueprint Load Configurations
# blueprints.load.initial-data may be overridden by ENV variables
blueprintsprocessor.loadInitialData=false
-blueprintsprocessor.loadBluePrint=false
-blueprintsprocessor.loadBluePrintPaths=/opt/app/onap/model-catalog/blueprint-model/service-blueprint
+blueprintsprocessor.loadBlueprint=false
+blueprintsprocessor.loadBlueprintPaths=/opt/app/onap/model-catalog/blueprint-model/service-blueprint
blueprintsprocessor.loadModelType=false
blueprintsprocessor.loadModeTypePaths=/opt/app/onap/model-catalog/definition-type/starter-type
blueprintsprocessor.loadResourceDictionary=false
import com.fasterxml.jackson.databind.node.TextNode
import kotlinx.coroutines.delay
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
@Component("component-remote-ansible-executor")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class ComponentRemoteAnsibleExecutor(
- private val blueprintRestLibPropertyService: BluePrintRestLibPropertyService,
+ private val blueprintRestLibPropertyService: BlueprintRestLibPropertyService,
private val mapper: ObjectMapper
) :
AbstractComponentFunction() {
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService.WebClientResponse
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.putJsonElement
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.test.context.TestPropertySource
import org.springframework.test.context.junit4.SpringRunner
)
} returns WebClientResponse(200, getReport())
val selector = mapper.readTree(endpointSelector)
- val bluePrintRestLibPropertyService = mockk<BluePrintRestLibPropertyService>()
+ val bluePrintRestLibPropertyService = mockk<BlueprintRestLibPropertyService>()
every { bluePrintRestLibPropertyService.blueprintWebClientService(selector) } returns webClientService
val awxRemoteExecutor = ComponentRemoteAnsibleExecutor(bluePrintRestLibPropertyService, mapper)
awxRemoteExecutor.checkDelay = 1
}
// then
- assertTrue(bluePrintRuntimeService.getBluePrintError().errors.isEmpty())
+ assertTrue(bluePrintRuntimeService.getBlueprintError().errors.isEmpty())
}
@Test
webClientService.exchangeResource("GET", "/api/v2/inventories/?name=Demo+Inventory", "")
} returns WebClientResponse(404, "")
val selector = mapper.readTree(endpointSelector)
- val bluePrintRestLibPropertyService = mockk<BluePrintRestLibPropertyService>()
+ val bluePrintRestLibPropertyService = mockk<BlueprintRestLibPropertyService>()
every { bluePrintRestLibPropertyService.blueprintWebClientService(selector) } returns webClientService
val awxRemoteExecutor = ComponentRemoteAnsibleExecutor(bluePrintRestLibPropertyService, mapper)
awxRemoteExecutor.checkDelay = 1
}
// then
- val errors = bluePrintRuntimeService.getBluePrintError().errors
+ val errors = bluePrintRuntimeService.getBlueprintError().errors
assertEquals(1, errors.size)
}
)
} returns WebClientResponse(500, "")
val selector = mapper.readTree(endpointSelector)
- val bluePrintRestLibPropertyService = mockk<BluePrintRestLibPropertyService>()
+ val bluePrintRestLibPropertyService = mockk<BlueprintRestLibPropertyService>()
every { bluePrintRestLibPropertyService.blueprintWebClientService(selector) } returns webClientService
val awxRemoteExecutor = ComponentRemoteAnsibleExecutor(bluePrintRestLibPropertyService, mapper)
awxRemoteExecutor.checkDelay = 1
}
// then
- val errors = bluePrintRuntimeService.getBluePrintError().errors
+ val errors = bluePrintRuntimeService.getBlueprintError().errors
assertEquals(1, errors.size)
}
private fun createBlueprintRuntimeService(
awxRemoteExecutor: ComponentRemoteAnsibleExecutor,
executionServiceInput: ExecutionServiceInput
- ): BluePrintRuntimeService<MutableMap<String, JsonNode>> {
- val bluePrintRuntimeService = BluePrintMetadataUtils.bluePrintRuntime(
+ ): BlueprintRuntimeService<MutableMap<String, JsonNode>> {
+ val bluePrintRuntimeService = BlueprintMetadataUtils.bluePrintRuntime(
"123456-1000",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/remote_ansible"
)
bluePrintRuntimeService.assignWorkflowInputs(workflowName, input)
val stepMetaData: MutableMap<String, JsonNode> = hashMapOf()
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "execute-remote-ansible")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentRemoteAnsibleExecutor")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_OPERATION, "process")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "execute-remote-ansible")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentRemoteAnsibleExecutor")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_OPERATION, "process")
val stepInputData = StepData().apply {
name = "execute-remote-ansible"
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.service.BlueprintSshClientService
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.sshClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
/**
* Register the CLI module exposed dependency
}
fun AbstractComponentFunction.getSshClientService(cliDeviceInfo: JsonNode): BlueprintSshClientService {
- return BluePrintDependencyService.sshClientService(cliDeviceInfo)
+ return BlueprintDependencyService.sshClientService(cliDeviceInfo)
}
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ActionIdentifiers
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.CommonHeader
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentScriptExecutor
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ExecutionServiceConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BluePrintSshLibConfiguration
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BlueprintSshLibConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintScriptsServiceImpl
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintScriptsServiceImpl
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.annotation.DirtiesContext
classes = [
CliExecutorConfiguration::class,
ExecutionServiceConfiguration::class,
- BluePrintSshLibConfiguration::class, BluePrintScriptsServiceImpl::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class, BluePrintDependencyService::class
+ BlueprintSshLibConfiguration::class, BlueprintScriptsServiceImpl::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class, BlueprintDependencyService::class
]
)
@DirtiesContext
}
payload = JacksonUtils.jsonNode("{}") as ObjectNode
}
- val bluePrintRuntime = mockk<DefaultBluePrintRuntimeService>("1234")
+ val bluePrintRuntime = mockk<DefaultBlueprintRuntimeService>("1234")
componentScriptExecutor.bluePrintRuntimeService = bluePrintRuntime
componentScriptExecutor.stepName = "sample-step"
val operationInputs = hashMapOf<String, JsonNode>()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "activate-cli".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_INTERFACE] = "interfaceName".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_OPERATION] = "operationName".asJsonPrimitive()
- operationInputs[ComponentScriptExecutor.INPUT_SCRIPT_TYPE] = BluePrintConstants.SCRIPT_INTERNAL.asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "activate-cli".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_INTERFACE] = "interfaceName".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_OPERATION] = "operationName".asJsonPrimitive()
+ operationInputs[ComponentScriptExecutor.INPUT_SCRIPT_TYPE] = BlueprintConstants.SCRIPT_INTERNAL.asJsonPrimitive()
operationInputs[ComponentScriptExecutor.INPUT_SCRIPT_CLASS_REFERENCE] =
"internal.scripts.TestCliScriptFunction".asJsonPrimitive()
}
executionServiceInput.stepData = stepInputData
- val blueprintContext = mockk<BluePrintContext>()
+ val blueprintContext = mockk<BlueprintContext>()
every {
blueprintContext.nodeTemplateOperationImplementation(
any(), any(), any()
import kotlinx.coroutines.withContext
import org.apache.logging.log4j.util.Strings
import org.onap.ccsdk.cds.blueprintsprocessor.functions.config.snapshots.db.ResourceConfigSnapshot.Status.RUNNING
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.slf4j.LoggerFactory
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.stereotype.Service
"dated=(${storedSnapshot.createdDate})"
)
} catch (ex: DataIntegrityViolationException) {
- throw BluePrintException("Failed to store configuration snapshot entry.", ex)
+ throw BlueprintException("Failed to store configuration snapshot entry.", ex)
}
storedSnapshot
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.config.snapshots.ComponentConfigSnapshotsExecutor.Companion.OPERATION_STORE
import org.onap.ccsdk.cds.blueprintsprocessor.functions.config.snapshots.db.ResourceConfigSnapshot
import org.onap.ccsdk.cds.blueprintsprocessor.functions.config.snapshots.db.ResourceConfigSnapshotService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.ComponentScan
@Autowired
lateinit var cfgSnapshotService: ResourceConfigSnapshotService
lateinit var cfgSnapshotComponent: ComponentConfigSnapshotsExecutor
- private var bluePrintRuntimeService = BluePrintMetadataUtils.bluePrintRuntime(
+ private var bluePrintRuntimeService = BlueprintMetadataUtils.bluePrintRuntime(
"123456-1000",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/remote_scripts"
)
prepareRequestProperties(OPERATION_FETCH, resId, resType, ResourceConfigSnapshot.Status.RUNNING.name)
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot lookup: provide resource-id and resource-type.",
e.message
prepareRequestProperties(OPERATION_FETCH, resId, resType, ResourceConfigSnapshot.Status.CANDIDATE.name)
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot lookup: provide resource-id and resource-type.",
e.message
prepareRequestProperties(OPERATION_STORE, resId, resType, snapshotConfig)
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot lookup: provide resource-id and resource-type.",
e.message
prepareRequestProperties(OPERATION_FETCH, "asdasd", "PNF", ResourceConfigSnapshot.Status.RUNNING.name)
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot lookup: provide resource-id and resource-type.",
e.message
prepareRequestProperties("update", "asdasd", "PNF", ResourceConfigSnapshot.Status.RUNNING.name)
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot lookup: provide resource-id and resource-type.",
e.message
}
// then; we should get error in our output properties
- assertTrue(bluePrintRuntimeService.getBluePrintError().errors.size == 1)
+ assertTrue(bluePrintRuntimeService.getBlueprintError().errors.size == 1)
assertEquals(
ComponentConfigSnapshotsExecutor.OUTPUT_STATUS_ERROR.asJsonPrimitive(),
bluePrintRuntimeService.getNodeTemplateAttributeValue(
prepareRequestProperties(OPERATION_DIFF, resId, resType, "YANG")
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot lookup: provide resource-id and resource-type.",
e.message
prepareRequestProperties(OPERATION_DIFF, resId, resType, DIFF_JSON)
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot diff: provide resource-id and resource-type.",
e.message
}
// then; we should get success
- assertTrue(bluePrintRuntimeService.getBluePrintError().errors.size == 0)
+ assertTrue(bluePrintRuntimeService.getBlueprintError().errors.size == 0)
assertEquals(
ComponentConfigSnapshotsExecutor.OUTPUT_STATUS_SUCCESS.asJsonPrimitive(),
bluePrintRuntimeService.getNodeTemplateAttributeValue(
prepareRequestProperties(OPERATION_DIFF, resId, resType, DIFF_XML)
cfgSnapshotComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
kotlin.test.assertEquals(
"Can't proceed with the cfg snapshot diff: provide resource-id and resource-type.",
e.message
}
// then; we should get success
- assertTrue(bluePrintRuntimeService.getBluePrintError().errors.size == 0)
+ assertTrue(bluePrintRuntimeService.getBlueprintError().errors.size == 0)
assertEquals(
ComponentConfigSnapshotsExecutor.OUTPUT_STATUS_SUCCESS.asJsonPrimitive(),
bluePrintRuntimeService.getNodeTemplateAttributeValue(
package org.onap.ccsdk.cds.blueprintsprocessor.functions.config.snapshots
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.PrimaryDatabaseConfiguration
import org.springframework.context.annotation.Bean
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = ["org.onap.ccsdk.cds.blueprintsprocessor.functions.config.snapshots"],
entityManagerFactoryRef = "primaryEntityManager",
import com.fasterxml.jackson.databind.ObjectMapper
import org.onap.ccsdk.cds.blueprintsprocessor.rest.BasicAuthRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.slf4j.LoggerFactory
import org.springframework.http.HttpMethod
import java.nio.file.Path
return result.status in 200..299
} catch (e: Exception) {
log.error("Caught exception trying to get k8s rb definition")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
return result.status in 200..299
} catch (e: Exception) {
log.error("Caught exception trying to get k8s rb profile")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.error("Caught exception trying to create k8s rb profile ${profile.profileName}")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
} catch (e: Exception) {
log.error("Caught exception trying to upload k8s rb profile ${profile.profileName}")
- throw BluePrintProcessorException("${e.message}")
+ throw BlueprintProcessorException("${e.message}")
}
}
}
import com.fasterxml.jackson.databind.node.ArrayNode
import com.fasterxml.jackson.databind.node.ObjectNode
import org.apache.commons.io.FileUtils
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.returnNullIfMissing
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintVelocityTemplateService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintVelocityTemplateService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ArchiveType
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
@Component("component-k8s-profile-upload")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class K8sProfileUploadComponent(
- private var bluePrintPropertiesService: BluePrintPropertiesService,
+ private var bluePrintPropertiesService: BlueprintPropertiesService,
private val resourceResolutionService: ResourceResolutionService
) :
val profileNamespace: String? = prefixInputParamsMap[INPUT_K8S_PROFILE_NAMESPACE]?.returnNullIfMissing()?.asText()
var profileSource: String? = prefixInputParamsMap[INPUT_K8S_PROFILE_SOURCE]?.returnNullIfMissing()?.asText()
if (profileNamespace == null)
- throw BluePrintProcessorException("Profile $profileName namespace is missing")
+ throw BlueprintProcessorException("Profile $profileName namespace is missing")
if (profileSource == null) {
profileSource = profileName
log.info("Profile name used instead of profile source")
}
val bluePrintContext = bluePrintRuntimeService.bluePrintContext()
val artifact: ArtifactDefinition = bluePrintContext.nodeTemplateArtifact(nodeTemplateName, profileSource)
- if (artifact.type != BluePrintConstants.MODEL_TYPE_ARTIFACT_K8S_PROFILE)
- throw BluePrintProcessorException(
+ if (artifact.type != BlueprintConstants.MODEL_TYPE_ARTIFACT_K8S_PROFILE)
+ throw BlueprintProcessorException(
"Unexpected profile artifact type for profile source " +
"$profileSource. Expecting: $artifact.type"
)
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ bluePrintRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
private fun getTemplatePrefixList(node: JsonNode?): ArrayList<String> {
tempProfilePath, manifestFiles
)
} else
- throw BluePrintProcessorException("Manifest file is missing")
+ throw BlueprintProcessorException("Manifest file is missing")
// Preparation of the final profile content
val finalProfileFilePath = Paths.get(
tempMainPath.toString().plus(File.separator).plus(
"$k8sRbProfileName.tar.gz"
)
)
- if (!BluePrintArchiveUtils.compress(
+ if (!BlueprintArchiveUtils.compress(
tempProfilePath, finalProfileFilePath.toFile(),
ArchiveType.TarGz
)
) {
- throw BluePrintProcessorException("Profile compression has failed")
+ throw BlueprintProcessorException("Profile compression has failed")
}
FileUtils.deleteDirectory(tempProfilePath)
throw t
}
} else
- throw BluePrintProcessorException("Profile source $ks8ProfileLocation is missing in CBA folder")
+ throw BlueprintProcessorException("Profile source $ks8ProfileLocation is missing in CBA folder")
}
private fun readManifestFiles(profileSource: File, destinationFolder: File): ArrayList<File>? {
if (!isFileInTheManifestFiles(finalFile, manifestFiles))
return
val fileContent = templatedFile.bufferedReader().readText()
- val finalFileContent = BluePrintVelocityTemplateService.generateContent(
+ val finalFileContent = BlueprintVelocityTemplateService.generateContent(
fileContent,
params, true
)
package org.onap.ccsdk.cds.blueprintsprocessor.functions.k8s.profile.upload
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
@Import(
- BluePrintPropertyConfiguration::class,
- BluePrintPropertiesService::class,
- BluePrintCoreConfiguration::class
+ BlueprintPropertyConfiguration::class,
+ BlueprintPropertiesService::class,
+ BlueprintCoreConfiguration::class
)
@EnableConfigurationProperties
-open class K8sProfileUploadConfiguration(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+open class K8sProfileUploadConfiguration(private var bluePrintPropertiesService: BlueprintPropertiesService) {
@Bean("k8s-plugin-properties")
open fun getProperties(): K8sProfileUploadProperties {
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.MessagePrioritization
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
/**
* Register the MessagePrioritizationStateService and exposed dependency
*/
-fun BluePrintDependencyService.messagePrioritizationStateService(): MessagePrioritizationStateService =
+fun BlueprintDependencyService.messagePrioritizationStateService(): MessagePrioritizationStateService =
instance(MessagePrioritizationStateService::class)
/**
* Expose messagePrioritizationStateService to AbstractComponentFunction
*/
fun AbstractComponentFunction.messagePrioritizationStateService() =
- BluePrintDependencyService.messagePrioritizationStateService()
+ BlueprintDependencyService.messagePrioritizationStateService()
/**
* MessagePrioritization correlation extensions
package org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.kafka
import org.apache.kafka.streams.processor.ProcessorContext
-import org.onap.ccsdk.cds.blueprintsprocessor.message.kafka.AbstractBluePrintMessageProcessor
+import org.onap.ccsdk.cds.blueprintsprocessor.message.kafka.AbstractBlueprintMessageProcessor
/** CDS Message Prioritization Kafka Stream Processor abstract class to implement */
-abstract class AbstractMessagePrioritizeProcessor<K, V> : AbstractBluePrintMessageProcessor<K, V>() {
+abstract class AbstractMessagePrioritizeProcessor<K, V> : AbstractBlueprintMessageProcessor<K, V>() {
override fun init(processorContext: ProcessorContext) {
this.processorContext = processorContext
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.MessagePrioritizationStateService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.MessageState
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.MessagePrioritization
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
override suspend fun processNB(key: ByteArray, value: ByteArray) {
val messagePrioritize = JacksonUtils.readValue(String(value), MessagePrioritization::class.java)
- ?: throw BluePrintProcessorException("failed to convert")
+ ?: throw BlueprintProcessorException("failed to convert")
try {
kafkaMessagePrioritizationService.prioritize(messagePrioritize)
} catch (e: Exception) {
if (kafkaMessagePrioritizationService is AbstractKafkaMessagePrioritizationService) {
kafkaMessagePrioritizationService.setKafkaProcessorContext(processorContext)
} else {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"messagePrioritizationService is not instance of " +
"AbstractKafkaMessagePrioritizationService, it is ${kafkaMessagePrioritizationService.javaClass}"
)
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.utils.MessageProcessorUtils.bluePrintProcessorSupplier
import org.onap.ccsdk.cds.blueprintsprocessor.message.KafkaStreamsBasicAuthConsumerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageConsumerProperties
-import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BluePrintMessageLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageConsumerService
import org.onap.ccsdk.cds.blueprintsprocessor.message.service.KafkaStreamConsumerFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.splitCommaAsList
open class KafkaMessagePrioritizationConsumer(
- private val bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService,
+ private val bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService,
private val kafkaMessagePrioritizationService: MessagePrioritizationService
) {
return object : KafkaStreamConsumerFunction {
val kafkaConsumerConfiguration = prioritizationConfiguration.kafkaConfiguration
- ?: throw BluePrintProcessorException("failed to get kafka consumer configuration")
+ ?: throw BlueprintProcessorException("failed to get kafka consumer configuration")
override suspend fun createTopology(
messageConsumerProperties: MessageConsumerProperties,
suspend fun startConsuming(prioritizationConfiguration: PrioritizationConfiguration) {
val kafkaConsumerConfiguration = prioritizationConfiguration.kafkaConfiguration
- ?: throw BluePrintProcessorException("failed to get kafka consumer configuration")
+ ?: throw BlueprintProcessorException("failed to get kafka consumer configuration")
streamingConsumerService = consumerService(kafkaConsumerConfiguration.inputTopicSelector)
import org.apache.kafka.common.serialization.Serde
import org.apache.kafka.common.serialization.Serializer
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.MessagePrioritization
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import java.nio.charset.Charset
return object : Deserializer<MessagePrioritization> {
override fun deserialize(topic: String, data: ByteArray): MessagePrioritization {
return JacksonUtils.readValue(String(data), MessagePrioritization::class.java)
- ?: throw BluePrintProcessorException("failed to convert")
+ ?: throw BlueprintProcessorException("failed to convert")
}
override fun configure(configs: MutableMap<String, *>?, isKey: Boolean) {
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.ids
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.service.AbstractMessagePrioritizationService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.utils.MessageProcessorUtils
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BluePrintNatsService
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BlueprintNatsService
import org.onap.ccsdk.cds.blueprintsprocessor.nats.utils.NatsClusterUtils
import org.onap.ccsdk.cds.controllerblueprints.core.asByteArray
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
private val log = logger(AbstractNatsMessagePrioritizationService::class)
- lateinit var bluePrintNatsService: BluePrintNatsService
+ lateinit var bluePrintNatsService: BlueprintNatsService
override suspend fun output(messages: List<MessagePrioritization>) {
log.info("$$$$$ received in output processor id(${messages.ids()})")
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.MessagePrioritizationService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.MessagePrioritization
import org.onap.ccsdk.cds.blueprintsprocessor.nats.asJsonType
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BluePrintNatsLibPropertyService
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BluePrintNatsService
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BlueprintNatsLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BlueprintNatsService
import org.onap.ccsdk.cds.blueprintsprocessor.nats.utils.NatsClusterUtils
import org.onap.ccsdk.cds.blueprintsprocessor.nats.utils.SubscriptionOptionsUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ClusterUtils
open class NatsMessagePrioritizationConsumer(
- private val bluePrintNatsLibPropertyService: BluePrintNatsLibPropertyService,
+ private val bluePrintNatsLibPropertyService: BlueprintNatsLibPropertyService,
private val natsMessagePrioritizationService: MessagePrioritizationService
) {
private val log = logger(NatsMessagePrioritizationConsumer::class)
- lateinit var bluePrintNatsService: BluePrintNatsService
+ lateinit var bluePrintNatsService: BlueprintNatsService
private lateinit var subscription: Subscription
suspend fun startConsuming() {
val prioritizationConfiguration = natsMessagePrioritizationService.getConfiguration()
val natsConfiguration = prioritizationConfiguration.natsConfiguration
- ?: throw BluePrintProcessorException("couldn't get NATS consumer configuration")
+ ?: throw BlueprintProcessorException("couldn't get NATS consumer configuration")
check((natsMessagePrioritizationService is AbstractNatsMessagePrioritizationService)) {
"messagePrioritizationService is not of type AbstractNatsMessagePrioritizationService."
log.info("Nats prioritization consumer listener shutdown complete")
}
- private fun consumerService(selector: String): BluePrintNatsService {
+ private fun consumerService(selector: String): BlueprintNatsService {
return bluePrintNatsLibPropertyService.bluePrintNatsService(selector)
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.MessagePrioritization
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.PrioritizationMessageRepository
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.toFormatedCorrelation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.utils.addDate
import org.onap.ccsdk.cds.controllerblueprints.core.utils.controllerDate
override suspend fun getMessage(id: String): MessagePrioritization {
return prioritizationMessageRepository.findById(id).orElseGet(null)
- ?: throw BluePrintProcessorException("couldn't find message for id($id)")
+ ?: throw BlueprintProcessorException("couldn't find message for id($id)")
}
override suspend fun getMessages(ids: List<String>): List<MessagePrioritization>? {
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.MessagePrioritization
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.toFormatedCorrelation
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.toTypeNCorrelation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
object MessageCorrelationUtils {
val unknownMessageTypes = collectedMessages.filter { !types.contains(it.type) }.map { it.id }
if (!unknownMessageTypes.isNullOrEmpty()) {
- throw BluePrintProcessorException("Messages($unknownMessageTypes) is not in type of($types)")
+ throw BlueprintProcessorException("Messages($unknownMessageTypes) is not in type of($types)")
}
val copyTypes = types.toTypedArray().copyOf().toMutableList()
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.MessagePrioritization
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.kafka.AbstractMessagePrioritizeProcessor
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.toFormatedCorrelation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
object MessageProcessorUtils {
/** Utility to create the cluster lock for message [messagePrioritization] prioritization procssing.*/
suspend fun prioritizationGrouplock(messagePrioritization: MessagePrioritization): ClusterLock? {
- val clusterService = BluePrintDependencyService.optionalClusterService()
+ val clusterService = BlueprintDependencyService.optionalClusterService()
return if (clusterService != null && clusterService.clusterJoined() &&
!messagePrioritization.correlationId.isNullOrBlank()
val lockName = "prioritize::${messagePrioritization.group}::$correlationId"
val clusterLock = clusterService.clusterLock(lockName)
clusterLock.lock()
- if (!clusterLock.isLocked()) throw BluePrintProcessorException("failed to lock($lockName)")
+ if (!clusterLock.isLocked()) throw BlueprintProcessorException("failed to lock($lockName)")
clusterLock
} else null
}
/** Utility to create the cluster lock for expiry scheduler*/
suspend fun prioritizationExpiryLock(): ClusterLock? {
- val clusterService = BluePrintDependencyService.optionalClusterService()
+ val clusterService = BlueprintDependencyService.optionalClusterService()
return if (clusterService != null && clusterService.clusterJoined()) {
val lockName = "prioritize-expiry"
val clusterLock = clusterService.clusterLock(lockName)
clusterLock.lock()
- if (!clusterLock.isLocked()) throw BluePrintProcessorException("failed to lock($lockName)")
+ if (!clusterLock.isLocked()) throw BlueprintProcessorException("failed to lock($lockName)")
clusterLock
} else null
}
/** Utility to create the cluster lock for expiry scheduler*/
suspend fun prioritizationCleanLock(): ClusterLock? {
- val clusterService = BluePrintDependencyService.optionalClusterService()
+ val clusterService = BlueprintDependencyService.optionalClusterService()
return if (clusterService != null && clusterService.clusterJoined()) {
val lockName = "prioritize-clean"
val clusterLock = clusterService.clusterLock(lockName)
clusterLock.lock()
- if (!clusterLock.isLocked()) throw BluePrintProcessorException("failed to lock($lockName)")
+ if (!clusterLock.isLocked()) throw BlueprintProcessorException("failed to lock($lockName)")
clusterLock
} else null
}
fun <K, V> bluePrintProcessorSupplier(name: String): ProcessorSupplier<K, V> {
return ProcessorSupplier<K, V> {
// Dynamically resolve the Prioritization Processor
- Blue
PrintDependencyService.instance<AbstractMessagePrioritizeProcessor<K, V>>(name)
+ Blue
printDependencyService.instance<AbstractMessagePrioritizeProcessor<K, V>>(name)
}
}
}
import kotlinx.coroutines.runBlocking
import org.junit.Before
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.db.PrioritizationMessageRepository
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.kafka.DefaultMessagePrioritizeProcessor
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.kafka.KafkaMessagePrioritizationConsumer
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.service.SampleMessagePrioritizationService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.service.SampleNatsMessagePrioritizationService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.message.prioritization.utils.MessagePrioritizationSample
-import org.onap.ccsdk.cds.blueprintsprocessor.message.BluePrintMessageLibConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BluePrintMessageLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.message.BlueprintMessageLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.message.service.KafkaMessageProducerService
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.BluePrintNatsLibConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BluePrintNatsLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.BlueprintNatsLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BlueprintNatsLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.nats.utils.NatsClusterUtils
import org.onap.ccsdk.cds.controllerblueprints.core.asByteArray
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.context.ApplicationContext
@DirtiesContext
@ContextConfiguration(
classes = [
- BluePrintMessageLibConfiguration::class, BluePrintNatsLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class,
+ BlueprintMessageLibConfiguration::class, BlueprintNatsLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class,
MessagePrioritizationConfiguration::class, TestDatabaseConfiguration::class
]
)
lateinit var prioritizationMessageRepository: PrioritizationMessageRepository
@Autowired
- lateinit var bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService
+ lateinit var bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService
@Autowired
- lateinit var bluePrintNatsLibPropertyService: BluePrintNatsLibPropertyService
+ lateinit var bluePrintNatsLibPropertyService: BlueprintNatsLibPropertyService
@Autowired
lateinit var messagePrioritizationStateService: MessagePrioritizationStateService
@Before
fun setup() {
- BluePrintDependencyService.inject(applicationContext)
+ BlueprintDependencyService.inject(applicationContext)
}
@Test
- fun testBluePrintKafkaJDBCKeyStore() {
+ fun testBlueprintKafkaJDBCKeyStore() {
runBlocking {
assertNotNull(prioritizationMessageRepository, "failed to get prioritizationMessageRepository")
- val messagePrioritizationService: MessagePrioritizationStateService = BluePrintDependencyService
+ val messagePrioritizationService: MessagePrioritizationStateService = BlueprintDependencyService
.instance(MessagePrioritizationStateService::class)
assertNotNull(messagePrioritizationService, "failed to get messagePrioritizationService")
)
// Register the processor
- BluePrintDependencyService.registerSingleton(
+ BlueprintDependencyService.registerSingleton(
MessagePrioritizationConstants.PROCESSOR_PRIORITIZE,
defaultMessagePrioritizeProcessor
)
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError()
+ bluePrintRuntimeService.getBlueprintError()
.addError("Failed in ComponentNetconfExecutor : ${runtimeException.message}")
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
/**
* Register the Netconf module exposed dependency
*/
-fun BluePrintDependencyService.netconfClientService(): ResourceResolutionService =
+fun BlueprintDependencyService.netconfClientService(): ResourceResolutionService =
instance(ResourceResolutionConstants.SERVICE_RESOURCE_RESOLUTION)
fun AbstractComponentFunction.netconfDevice(requirementName: String): NetconfDevice {
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.scripts.BlueprintJythonService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.putJsonElement
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.context.ApplicationContext
ExecutionServiceInput::class.java
)!!
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
// TODO("Set Attribute properties")
val stepMetaData: MutableMap<String, JsonNode> = hashMapOf()
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "activate-netconf")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentNetconfExecutor")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_OPERATION, "process")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "activate-netconf")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentNetconfExecutor")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_OPERATION, "process")
// Set Step Inputs in Blueprint Runtime Service
componentNetconfExecutor.bluePrintRuntimeService = bluePrintRuntimeService
val stepInputData = StepData().apply {
import org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor.scripts.BlueprintJythonServiceImpl
import org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor.scripts.PythonExecutorConstants
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.data.OperationAssignment
import org.slf4j.LoggerFactory
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError()
+ bluePrintRuntimeService.getBlueprintError()
.addError("Failed in ComponentJythonExecutor : ${runtimeException.message}")
}
.nodeTemplateInterfaceOperation(nodeTemplateName, interfaceName, operationName)
val artifactName: String = operationAssignment.implementation?.primary
- ?: throw BluePrintProcessorException("missing primary field to get artifact name for node template ($nodeTemplateName)")
+ ?: throw BlueprintProcessorException("missing primary field to get artifact name for node template ($nodeTemplateName)")
val artifactDefinition = bluePrintRuntimeService.resolveNodeTemplateArtifactDefinition(nodeTemplateName, artifactName)
val pythonFileName = artifactDefinition.file
- ?: throw BluePrintProcessorException("missing file name for node template ($nodeTemplateName)'s artifactName($artifactName)")
+ ?: throw BlueprintProcessorException("missing file name for node template ($nodeTemplateName)'s artifactName($artifactName)")
val pythonClassName = FilenameUtils.getBaseName(pythonFileName)
checkNotEmpty(content) { "artifact ($artifactName) content is empty" }
val instanceDependenciesNode: ArrayNode = operationInputs[PythonExecutorConstants.INPUT_INSTANCE_DEPENDENCIES] as? ArrayNode
- ?: throw BluePrintProcessorException("Failed to get property(${PythonExecutorConstants.INPUT_INSTANCE_DEPENDENCIES})")
+ ?: throw BlueprintProcessorException("Failed to get property(${PythonExecutorConstants.INPUT_INSTANCE_DEPENDENCIES})")
val jythonInstance: MutableMap<String, Any> = hashMapOf()
jythonInstance["log"] = LoggerFactory.getLogger(pythonClassName)
componentFunction.operationName = operationName
componentFunction.processId = processId
componentFunction.workflowName = workflowName
- componentFunction.scriptType = BluePrintConstants.SCRIPT_JYTHON
+ componentFunction.scriptType = BlueprintConstants.SCRIPT_JYTHON
}
}
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.async
import kotlinx.coroutines.withTimeout
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.PrepareRemoteEnvInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.RemoteIdentifier
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ExecutionServiceConstant
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.RemoteScriptExecutionService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.checkFileExists
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotBlank
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class ComponentRemotePythonExecutor(
private val remoteScriptExecutionService: RemoteScriptExecutionService,
- private var bluePrintPropertiesService: BluePrintPropertiesService
+ private var bluePrintPropertiesService: BlueprintPropertiesService
) : AbstractComponentFunction() {
private val log = LoggerFactory.getLogger(ComponentRemotePythonExecutor::class.java)!!
.nodeTemplateInterfaceOperation(nodeTemplateName, interfaceName, operationName)
val artifactName: String = operationAssignment.implementation?.primary
- ?: throw BluePrintProcessorException("missing primary field to get artifact name for node template ($nodeTemplateName)")
+ ?: throw BlueprintProcessorException("missing primary field to get artifact name for node template ($nodeTemplateName)")
val artifactDefinition =
bluePrintRuntimeService.resolveNodeTemplateArtifactDefinition(nodeTemplateName, artifactName)
log.error(catchallErrMsg, e)
}
// if Env preparation was successful, then proceed with command execution in this Env
- if (bluePrintRuntimeService.getBluePrintError().errors.isEmpty()) {
+ if (bluePrintRuntimeService.getBlueprintError().errors.isEmpty()) {
try {
// Populate command execution properties and pass it to the remote server
val properties = dynamicProperties?.returnNullIfMissing()?.rootFieldsToMap() ?: hashMapOf()
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError()
+ bluePrintRuntimeService.getBlueprintError()
.addError("Failed in ComponentRemotePythonExecutor : ${runtimeException.message}")
}
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.ArrayNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
/** Component Extensions **/
-fun BluePrintTypes.nodeTypeComponentRemotePythonExecutor(): NodeType {
+fun BlueprintTypes.nodeTypeComponentRemotePythonExecutor(): NodeType {
return nodeType(
- id = "component-remote-python-executor", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_COMPONENT,
+ id = "component-remote-python-executor", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_COMPONENT,
description = "This is Remote Python Execution Component."
) {
attribute(
- ComponentRemotePythonExecutor.ATTRIBUTE_PREPARE_ENV_LOG, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentRemotePythonExecutor.ATTRIBUTE_PREPARE_ENV_LOG, BlueprintConstants.DATA_TYPE_STRING,
false
)
attribute(
- ComponentRemotePythonExecutor.ATTRIBUTE_EXEC_CMD_LOG, BluePrintConstants.DATA_TYPE_LIST,
+ ComponentRemotePythonExecutor.ATTRIBUTE_EXEC_CMD_LOG, BlueprintConstants.DATA_TYPE_LIST,
false
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
attribute(
- ComponentRemotePythonExecutor.ATTRIBUTE_RESPONSE_DATA, BluePrintConstants.DATA_TYPE_JSON,
+ ComponentRemotePythonExecutor.ATTRIBUTE_RESPONSE_DATA, BlueprintConstants.DATA_TYPE_JSON,
false
)
operation("ComponentRemotePythonExecutor", "ComponentRemotePythonExecutor Operation") {
inputs {
property(
- ComponentRemotePythonExecutor.INPUT_ENDPOINT_SELECTOR, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentRemotePythonExecutor.INPUT_ENDPOINT_SELECTOR, BlueprintConstants.DATA_TYPE_STRING,
false, "Remote Container or Server selector name."
) {
defaultValue(ComponentRemotePythonExecutor.DEFAULT_SELECTOR)
}
property(
- ComponentRemotePythonExecutor.INPUT_DYNAMIC_PROPERTIES, BluePrintConstants.DATA_TYPE_JSON,
+ ComponentRemotePythonExecutor.INPUT_DYNAMIC_PROPERTIES, BlueprintConstants.DATA_TYPE_JSON,
false, "Dynamic Json Content or DSL Json reference."
)
property(
- ComponentRemotePythonExecutor.INPUT_ARGUMENT_PROPERTIES, BluePrintConstants.DATA_TYPE_JSON,
+ ComponentRemotePythonExecutor.INPUT_ARGUMENT_PROPERTIES, BlueprintConstants.DATA_TYPE_JSON,
false, "Argument Json Content or DSL Json reference."
)
property(
- ComponentRemotePythonExecutor.INPUT_COMMAND, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentRemotePythonExecutor.INPUT_COMMAND, BlueprintConstants.DATA_TYPE_STRING,
true, "Command to execute."
)
property(
- ComponentRemotePythonExecutor.INPUT_PACKAGES, BluePrintConstants.DATA_TYPE_LIST,
+ ComponentRemotePythonExecutor.INPUT_PACKAGES, BlueprintConstants.DATA_TYPE_LIST,
false, "Packages to install based on type."
) {
entrySchema("dt-system-packages")
}
}
-fun BluePrintTypes.dataTypeDtSystemPackages(): DataType {
+fun BlueprintTypes.dataTypeDtSystemPackages(): DataType {
return dataType(
- id = "dt-system-packages", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT,
+ id = "dt-system-packages", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT,
description = "This represent System Package Data Type"
) {
- property("type", BluePrintConstants.DATA_TYPE_LIST, true, "") {
+ property("type", BlueprintConstants.DATA_TYPE_LIST, true, "") {
constrain {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
validValues(arrayListOf("ansible_galaxy".asJsonPrimitive(), "pip".asJsonPrimitive()))
}
}
- property("package", BluePrintConstants.DATA_TYPE_LIST, true, "") {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ property("package", BlueprintConstants.DATA_TYPE_LIST, true, "") {
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
}
}
/** Component Builder */
-fun BluePrintTypes.nodeTemplateComponentRemotePythonExecutor(
+fun BlueprintTypes.nodeTemplateComponentRemotePythonExecutor(
id: String,
description: String,
block: ComponentRemotePythonExecutorNodeTemplateBuilder.() -> Unit
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
open class JythonComponentFunction : AbstractScriptComponentFunction() {
override suspend fun processNB(executionRequest: ExecutionServiceInput) {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
}
import org.apache.commons.io.FilenameUtils
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.scripts.BlueprintJythonService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.data.OperationAssignment
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintFunctionNode
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.Logger
import org.slf4j.LoggerFactory
val log: Logger = LoggerFactory.getLogger(BlueprintJythonService::class.java)
inline fun <reified T> jythonInstance(
- blueprintContext: BluePrintContext,
+ blueprintContext: BlueprintContext,
pythonClassName: String,
content: String,
dependencyInstanceNames: MutableMap<String, Any>?
pythonPath.addAll(pythonExecutorProperty.modulePaths)
val blueprintPythonConfigurations =
- BluePrintPython(pythonExecutorProperty.executionPath, pythonPath, arrayListOf())
+ BlueprintPython(pythonExecutorProperty.executionPath, pythonPath, arrayListOf())
val blueprintPythonHost = BlueprintPythonHost(blueprintPythonConfigurations)
val pyObject = blueprintPythonHost.getPythonComponent(content, pythonClassName, dependencyInstanceNames)
return pyObject.__tojava__(T::class.java) as T
}
- override fun jythonComponentInstance(bluePrintContext: BluePrintContext, scriptClassReference: String):
+ override fun jythonComponentInstance(bluePrintContext: BlueprintContext, scriptClassReference: String):
BlueprintFunctionNode<*, *> {
val pythonFileName = bluePrintContext.rootPath
val blueprintBasePath: String = bluePrintContext.rootPath
val artifactName: String = operationAssignment.implementation?.primary
- ?: throw BluePrintProcessorException("missing primary field to get artifact name for node template ($nodeTemplateName)")
+ ?: throw BlueprintProcessorException("missing primary field to get artifact name for node template ($nodeTemplateName)")
val artifactDefinition =
bluePrintRuntimeService.resolveNodeTemplateArtifactDefinition(nodeTemplateName, artifactName)
val pythonFileName = artifactDefinition.file
- ?: throw BluePrintProcessorException("missing file name for node template ($nodeTemplateName)'s artifactName($artifactName)")
+ ?: throw BlueprintProcessorException("missing file name for node template ($nodeTemplateName)'s artifactName($artifactName)")
val pythonClassName = FilenameUtils.getBaseName(pythonFileName)
log.info("Getting Jython Script Class($pythonClassName)")
val instanceDependenciesNode: ArrayNode =
operationInputs[PythonExecutorConstants.INPUT_INSTANCE_DEPENDENCIES] as? ArrayNode
- ?: throw BluePrintProcessorException("Failed to get property(${PythonExecutorConstants.INPUT_INSTANCE_DEPENDENCIES})")
+ ?: throw BlueprintProcessorException("Failed to get property(${PythonExecutorConstants.INPUT_INSTANCE_DEPENDENCIES})")
instanceDependenciesNode.forEach { instanceName ->
jythonInstances[instanceName.textValue()] = applicationContext.getBean(instanceName.textValue())
package org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor.scripts
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ExecutionServiceDomains
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.updateErrorMessage
import org.python.core.PyObject
import org.python.util.PythonInterpreter
@Deprecated("CDS won't support JythonService")
-open class BlueprintPythonHost(private val bluePrintPython: BluePrintPython) {
+open class BlueprintPythonHost(private val bluePrintPython: BlueprintPython) {
private val blueprintPythonInterpreterProxy: BlueprintPythonInterpreterProxy
bluePrintPython.moduleName = "Blueprint Python Script [Class Name = $interfaceName]"
try {
return blueprintPythonInterpreterProxy.getPythonInstance(properties)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Failed to get python instance."
throw e.updateErrorMessage(
ExecutionServiceDomains.PYTHON_EXECUTOR, errorMsg,
"Error in environment properties"
)
} catch (e: Exception) {
- throw BluePrintProcessorException("Failed to execute Jython component $e", e)
+ throw BlueprintProcessorException("Failed to execute Jython component $e", e)
}
}
*/
package org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor.scripts
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.python.core.PyObject
import org.python.core.PySyntaxError
import org.python.util.PythonInterpreter
@Deprecated("CDS won't support JythonService")
-open class BlueprintPythonInterpreterProxy(private val bluePrintPython: BluePrintPython) : PythonInterpreter() {
+open class BlueprintPythonInterpreterProxy(private val bluePrintPython: BlueprintPython) : PythonInterpreter() {
fun getPythonInstance(properties: MutableMap<String, Any>?): PyObject {
properties?.forEach { (name, value) ->
try {
this.exec(bluePrintPython.content)
} catch (e: PySyntaxError) {
- throw BluePrintProcessorException("Error executing Jython code! Python error: '$e'", e)
+ throw BlueprintProcessorException("Error executing Jython code! Python error: '$e'", e)
}
}
}
@Deprecated("CDS won't support JythonService")
-open class BluePrintPython(
+open class BlueprintPython(
executablePath: String,
blueprintPythonPlatform: MutableList<String>,
val argv: MutableList<String>
import org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor.mock.MockInstanceConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor.scripts.PythonExecutorConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor.scripts.PythonExecutorProperty
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.putJsonElement
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
ExecutionServiceInput::class.java
)!!
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
val stepMetaData: MutableMap<String, JsonNode> = hashMapOf()
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "activate-jython")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentJythonExecutor")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_OPERATION, "process")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "activate-jython")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentJythonExecutor")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_OPERATION, "process")
componentJythonExecutor.bluePrintRuntimeService = bluePrintRuntimeService
val stepInputData = StepData().apply {
name = "activate-jython"
package org.onap.ccsdk.cds.blueprintsprocessor.functions.python.executor
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import kotlin.test.assertNotNull
class ComponentRemotePythonExecutorDSLTest {
@Test
fun testNodeTypeComponentRemotePythonExecutor() {
- val nodeType = BluePrintTypes.nodeTypeComponentRemotePythonExecutor()
+ val nodeType = BlueprintTypes.nodeTypeComponentRemotePythonExecutor()
// println(nodeType.asJsonString(true))
assertNotNull(nodeType, "failed to generate nodeTypeComponentRemotePythonExecutor")
}
@Test
fun testNodeTemplateComponentRemotePythonExecutor() {
- val nodeTemplate = BluePrintTypes.nodeTemplateComponentRemotePythonExecutor(
+ val nodeTemplate = BlueprintTypes.nodeTemplateComponentRemotePythonExecutor(
"test-nodetemplate",
"test nodetemplate"
) {
import io.mockk.mockk
import kotlinx.coroutines.runBlocking
import org.junit.Test
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.PrepareRemoteEnvInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.RemoteScriptExecutionInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StatusType
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.RemoteScriptExecutionService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.putJsonElement
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
val componentRemotePythonExecutor = ComponentRemotePythonExecutor(
remoteScriptExecutionService,
- mockk<BluePrintPropertiesService>()
+ mockk<BlueprintPropertiesService>()
)
val executionServiceInput =
ExecutionServiceInput::class.java
)!!
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"123456-1000",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/remote_scripts"
)
)
val stepMetaData: MutableMap<String, JsonNode> = hashMapOf()
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "execute-remote-python")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentRemotePythonExecutor")
- stepMetaData.putJsonElement(BluePrintConstants.PROPERTY_CURRENT_OPERATION, "process")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE, "execute-remote-python")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_INTERFACE, "ComponentRemotePythonExecutor")
+ stepMetaData.putJsonElement(BlueprintConstants.PROPERTY_CURRENT_OPERATION, "process")
componentRemotePythonExecutor.bluePrintRuntimeService = bluePrintRuntimeService
val stepInputData = StepData().apply {
name = "execute-remote-python"
val remoteScriptExecutionService = MockRemoteScriptExecutionService()
val componentRemotePythonExecutor = ComponentRemotePythonExecutor(
remoteScriptExecutionService,
- mockk<BluePrintPropertiesService>()
+ mockk<BlueprintPropertiesService>()
)
- val bluePrintRuntime = mockk<DefaultBluePrintRuntimeService>("123456-1000")
+ val bluePrintRuntime = mockk<DefaultBlueprintRuntimeService>("123456-1000")
- every { bluePrintRuntime.getBluePrintError() } answers { BluePrintError() } // successful case.
+ every { bluePrintRuntime.getBlueprintError() } answers { BlueprintError() } // successful case.
every { bluePrintRuntime.setNodeTemplateAttributeValue(any(), any(), any()) } answers {}
val input = getMockedOutput(bluePrintRuntime)
/**
* Mocked input information for remote python executor.
*/
- fun getMockedOutput(svc: DefaultBluePrintRuntimeService):
+ fun getMockedOutput(svc: DefaultBlueprintRuntimeService):
ExecutionServiceInput {
val stepMetaData: MutableMap<String, JsonNode> = hashMapOf()
stepMetaData.putJsonElement(
- BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE,
+ BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE,
"execute-remote-python"
)
stepMetaData.putJsonElement(
- BluePrintConstants.PROPERTY_CURRENT_INTERFACE,
+ BlueprintConstants.PROPERTY_CURRENT_INTERFACE,
"ComponentRemotePythonExecutor"
)
stepMetaData.putJsonElement(
- BluePrintConstants.PROPERTY_CURRENT_OPERATION, "process"
+ BlueprintConstants.PROPERTY_CURRENT_OPERATION, "process"
)
val mapper = ObjectMapper()
val operationalInputs: MutableMap<String, JsonNode> = hashMapOf()
operationalInputs.putJsonElement(
- BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE,
+ BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE,
"execute-remote-python"
)
operationalInputs.putJsonElement(
- BluePrintConstants.PROPERTY_CURRENT_INTERFACE,
+ BlueprintConstants.PROPERTY_CURRENT_INTERFACE,
"ComponentRemotePythonExecutor"
)
operationalInputs.putJsonElement(
- BluePrintConstants.PROPERTY_CURRENT_OPERATION, "process"
+ BlueprintConstants.PROPERTY_CURRENT_OPERATION, "process"
)
operationalInputs.putJsonElement("endpoint-selector", "aai")
operationalInputs.putJsonElement("dynamic-properties", rootNode)
"ComponentRemotePythonExecutor", "process"
)
} returns operationOutputs
- val bluePrintRuntimeService = BluePrintMetadataUtils.bluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.bluePrintRuntime(
"123456-1000",
"./../../../../components/model-" +
"catalog/blueprint-model/test-blueprint/" +
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
"blueprints.processor.functions.python.executor.executionPath=./../../../../components/scripts/python/ccsdk_blueprints"])
class BlueprintJythonServiceTest {
- lateinit var blueprintContext: BluePrintContext
+ lateinit var blueprintContext: BlueprintContext
@Autowired
private lateinit var blueprintJythonService: BlueprintJythonServiceImpl
@BeforeTest
fun init() {
- blueprintContext = mockk<BluePrintContext>()
+ blueprintContext = mockk<BlueprintContext>()
every { blueprintContext.rootPath } returns normalizedPathName("target")
}
import kotlin.test.assertNotNull
@RunWith(SpringRunner::class)
-@ContextConfiguration(classes = [BluePrintPython::class, PythonExecutorProperty::class, String::class])
+@ContextConfiguration(classes = [BlueprintPython::class, PythonExecutorProperty::class, String::class])
@TestPropertySource(
properties =
[
pythonPath.add(blueprintBasePath)
pythonPath.addAll(pythonExecutorProperty.modulePaths)
- blueprintPythonHost = BlueprintPythonHost(BluePrintPython(pythonExecutorProperty.executionPath, pythonPath, arrayListOf()))
+ blueprintPythonHost = BlueprintPythonHost(BlueprintPython(pythonExecutorProperty.executionPath, pythonPath, arrayListOf()))
}
@Test
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
-class ResourceAssignmentRuntimeService(private var id: String, private var bluePrintContext: BluePrintContext) :
- DefaultBluePrintRuntimeService(id, bluePrintContext) {
+class ResourceAssignmentRuntimeService(private var id: String, private var bluePrintContext: BlueprintContext) :
+ DefaultBlueprintRuntimeService(id, bluePrintContext) {
private lateinit var resolutionId: String
private var resourceStore: MutableMap<String, JsonNode> = hashMapOf()
fun getResolutionStore(key: String): JsonNode {
return resourceStore[key]
- ?: throw BluePrintProcessorException("failed to get execution property ($key)")
+ ?: throw BlueprintProcessorException("failed to get execution property ($key)")
}
fun checkResolutionStore(key: String): Boolean {
fun getDictionaryStore(key: String): JsonNode {
return resourceStore["dictionary-$key"]
- ?: throw BluePrintProcessorException("failed to get execution property (dictionary-$key)")
+ ?: throw BlueprintProcessorException("failed to get execution property (dictionary-$key)")
}
fun checkDictionaryStore(key: String): Boolean {
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.PropertyDefinitionBuilder
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
/** Resource Definition DSL **/
-fun BluePrintTypes.resourceDefinitions(block: ResourceDefinitionsBuilder.() -> Unit):
+fun BlueprintTypes.resourceDefinitions(block: ResourceDefinitionsBuilder.() -> Unit):
MutableMap<String, ResourceDefinition> {
return ResourceDefinitionsBuilder().apply(block).build()
}
-fun BluePrintTypes.resourceDefinition(
+fun BlueprintTypes.resourceDefinition(
name: String,
description: String,
block: ResourceDefinitionBuilder.() -> Unit
}
/** Resource Mapping DSL **/
-fun BluePrintTypes.resourceAssignments(block: ResourceAssignmentsBuilder.() -> Unit):
+fun BlueprintTypes.resourceAssignments(block: ResourceAssignmentsBuilder.() -> Unit):
MutableMap<String, ResourceAssignment> {
return ResourceAssignmentsBuilder().apply(block).build()
}
-fun BluePrintTypes.resourceAssignment(
+fun BlueprintTypes.resourceAssignment(
name: String,
dictionaryName: String,
dictionarySource: String,
import com.fasterxml.jackson.databind.node.ObjectNode
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.asObjectNode
import org.onap.ccsdk.cds.controllerblueprints.core.returnNullIfMissing
// validate inputs if we need to store the resource and template resolution.
if (storeResult) {
if (resolutionKey.isNotEmpty() && (resourceId.isNotEmpty() || resourceType.isNotEmpty())) {
- throw BluePrintProcessorException("Can't proceed with the resolution: either provide resolution-key OR combination of resource-id and resource-type.")
+ throw BlueprintProcessorException("Can't proceed with the resolution: either provide resolution-key OR combination of resource-id and resource-type.")
} else if ((resourceType.isNotEmpty() && resourceId.isEmpty()) || (resourceType.isEmpty() && resourceId.isNotEmpty())) {
- throw BluePrintProcessorException("Can't proceed with the resolution: both resource-id and resource-type should be provided, one of them is missing.")
+ throw BlueprintProcessorException("Can't proceed with the resolution: both resource-id and resource-type should be provided, one of them is missing.")
} else if (resourceType.isEmpty() && resourceId.isEmpty() && resolutionKey.isEmpty()) {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Can't proceed with the resolution: can't persist resolution without a correlation key. " +
"Either provide a resolution-key OR combination of resource-id and resource-type OR set `storeResult` to false."
)
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ bluePrintRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
/** Component Extensions **/
fun ServiceTemplateBuilder.nodeTypeComponentResourceResolution() {
- val nodeType = BluePrintTypes.nodeTypeComponentResourceResolution()
+ val nodeType = BlueprintTypes.nodeTypeComponentResourceResolution()
if (this.nodeTypes == null) this.nodeTypes = hashMapOf()
this.nodeTypes!![nodeType.id!!] = nodeType
}
-fun BluePrintTypes.nodeTypeComponentResourceResolution(): NodeType {
+fun BlueprintTypes.nodeTypeComponentResourceResolution(): NodeType {
return nodeType(
- id = "component-resource-resolution", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_COMPONENT,
+ id = "component-resource-resolution", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_COMPONENT,
description = "Resource Assignment Component"
) {
attribute(
- ResourceResolutionComponent.ATTRIBUTE_ASSIGNMENT_PARAM, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.ATTRIBUTE_ASSIGNMENT_PARAM, BlueprintConstants.DATA_TYPE_STRING,
true
)
attribute(
- ResourceResolutionComponent.ATTRIBUTE_STATUS, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.ATTRIBUTE_STATUS, BlueprintConstants.DATA_TYPE_STRING,
true
)
operation("ResourceResolutionComponent", "ResourceResolutionComponent Operation") {
inputs {
property(
- ResourceResolutionComponent.INPUT_REQUEST_ID, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.INPUT_REQUEST_ID, BlueprintConstants.DATA_TYPE_STRING,
true, "Request Id, Unique Id for the request."
)
property(
- ResourceResolutionComponent.INPUT_RESOURCE_ID, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.INPUT_RESOURCE_ID, BlueprintConstants.DATA_TYPE_STRING,
false, "Resource Id."
)
property(
- ResourceResolutionComponent.INPUT_ACTION_NAME, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.INPUT_ACTION_NAME, BlueprintConstants.DATA_TYPE_STRING,
false, "Action Name of the process"
)
property(
- ResourceResolutionComponent.INPUT_DYNAMIC_PROPERTIES, BluePrintConstants.DATA_TYPE_JSON,
+ ResourceResolutionComponent.INPUT_DYNAMIC_PROPERTIES, BlueprintConstants.DATA_TYPE_JSON,
false, "Dynamic Json Content or DSL Json reference."
)
property(
- ResourceResolutionComponent.INPUT_RESOLUTION_KEY, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.INPUT_RESOLUTION_KEY, BlueprintConstants.DATA_TYPE_STRING,
false, "Key for service instance related correlation."
)
property(
- ResourceResolutionComponent.INPUT_RESOLUTION_SUMMARY, BluePrintConstants.DATA_TYPE_BOOLEAN,
+ ResourceResolutionComponent.INPUT_RESOLUTION_SUMMARY, BlueprintConstants.DATA_TYPE_BOOLEAN,
false, "Enables ResolutionSummary output"
)
property(
- ResourceResolutionComponent.INPUT_OCCURRENCE, BluePrintConstants.DATA_TYPE_INTEGER,
+ ResourceResolutionComponent.INPUT_OCCURRENCE, BlueprintConstants.DATA_TYPE_INTEGER,
false, "Number of time to perform the resolution."
) {
defaultValue(1)
}
property(
- ResourceResolutionComponent.INPUT_STORE_RESULT, BluePrintConstants.DATA_TYPE_BOOLEAN,
+ ResourceResolutionComponent.INPUT_STORE_RESULT, BlueprintConstants.DATA_TYPE_BOOLEAN,
false, "Whether or not to store the output."
)
property(
- ResourceResolutionComponent.INPUT_RESOURCE_TYPE, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.INPUT_RESOURCE_TYPE, BlueprintConstants.DATA_TYPE_STRING,
false, "Request type."
)
property(
- ResourceResolutionComponent.INPUT_ARTIFACT_PREFIX_NAMES, BluePrintConstants.DATA_TYPE_LIST,
+ ResourceResolutionComponent.INPUT_ARTIFACT_PREFIX_NAMES, BlueprintConstants.DATA_TYPE_LIST,
true, "Template , Resource Assignment Artifact Prefix names"
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
}
outputs {
property(
- ResourceResolutionComponent.OUTPUT_RESOURCE_ASSIGNMENT_PARAMS, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.OUTPUT_RESOURCE_ASSIGNMENT_PARAMS, BlueprintConstants.DATA_TYPE_STRING,
true, "Output Response"
)
property(
- ResourceResolutionComponent.OUTPUT_RESOURCE_ASSIGNMENT_MAP, BluePrintConstants.DATA_TYPE_MAP,
+ ResourceResolutionComponent.OUTPUT_RESOURCE_ASSIGNMENT_MAP, BlueprintConstants.DATA_TYPE_MAP,
true, "Output Resolved Values"
)
property(
- ResourceResolutionComponent.OUTPUT_STATUS, BluePrintConstants.DATA_TYPE_STRING,
+ ResourceResolutionComponent.OUTPUT_STATUS, BlueprintConstants.DATA_TYPE_STRING,
true, "Status of the Component Execution ( success or failure )"
)
}
description: String,
block: ComponentResourceResolutionNodeTemplateBuilder.() -> Unit
) {
- val nodeTemplate = BluePrintTypes.nodeTemplateComponentResourceResolution(
+ val nodeTemplate = BlueprintTypes.nodeTemplateComponentResourceResolution(
id, description,
block
)
nodeTemplates!![nodeTemplate.id!!] = nodeTemplate
}
-fun BluePrintTypes.nodeTemplateComponentResourceResolution(
+fun BlueprintTypes.nodeTemplateComponentResourceResolution(
id: String,
description: String,
block: ComponentResourceResolutionNodeTemplateBuilder.() -> Unit
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.db.ResourceResolution
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.db.ResourceResolutionDBService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
/**
* Register the Resolution module exposed dependency
*/
-fun BluePrintDependencyService.resourceResolutionService(): ResourceResolutionService =
+fun BlueprintDependencyService.resourceResolutionService(): ResourceResolutionService =
instance(ResourceResolutionConstants.SERVICE_RESOURCE_RESOLUTION)
-fun BluePrintDependencyService.resourceResolutionDBService(): ResourceResolutionDBService =
+fun BlueprintDependencyService.resourceResolutionDBService(): ResourceResolutionDBService =
instance(ResourceResolutionDBService::class.java)
suspend fun AbstractComponentFunction.storedContentFromResolvedArtifactNB(
resolutionKey: String,
artifactName: String
): String {
- return BluePrintDependencyService.resourceResolutionService()
+ return BlueprintDependencyService.resourceResolutionService()
.resolveFromDatabase(bluePrintRuntimeService, artifactName, resolutionKey)
}
artifactName: String,
occurrence: Int = 1
): List<ResourceResolution> {
- return BluePrintDependencyService.resourceResolutionDBService()
+ return BlueprintDependencyService.resourceResolutionDBService()
.findByBlueprintNameAndBlueprintVersionAndArtifactNameAndResolutionKeyAndOccurrence(
bluePrintRuntimeService,
resolutionKey,
* Return resolved and mashed artifact content for artifact prefix [artifactPrefix]
*/
suspend fun AbstractComponentFunction.contentFromResolvedArtifactNB(artifactPrefix: String): String {
- return BluePrintDependencyService.resourceResolutionService()
+ return BlueprintDependencyService.resourceResolutionService()
.resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactPrefix, mapOf())
.first
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceDefinitionUtils.createResourceAssignments
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.common.ApplicationConstants.LOG_REDACTED
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintTemplateService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintTemplateService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.PropertyDefinitionUtils.Companion.hasLogProtect
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
fun registeredResourceSources(): List<String>
suspend fun resolveFromDatabase(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
artifactTemplate: String,
resolutionKey: String
): String
suspend fun resolveResources(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
nodeTemplateName: String,
artifactNames: List<String>,
properties: Map<String, Any>
): ResourceResolutionResult
suspend fun resolveResources(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
nodeTemplateName: String,
artifactPrefix: String,
properties: Map<String, Any>
* with other [resourceDefinitions] dependencies for the sources [sources]
* Used to get the same resource values from multiple sources. **/
suspend fun resolveResourceDefinition(
- blueprintRuntimeService: BluePrintRuntimeService<*>,
+ blueprintRuntimeService: BlueprintRuntimeService<*>,
resourceDefinitions: MutableMap<String, ResourceDefinition>,
resolveDefinition: String,
sources: List<String>
MutableMap<String, JsonNode>
suspend fun resolveResourceAssignments(
- blueprintRuntimeService: BluePrintRuntimeService<*>,
+ blueprintRuntimeService: BlueprintRuntimeService<*>,
resourceDefinitions: MutableMap<String, ResourceDefinition>,
resourceAssignments: MutableList<ResourceAssignment>,
artifactPrefix: String,
open class ResourceResolutionServiceImpl(
private var applicationContext: ApplicationContext,
private var templateResolutionDBService: TemplateResolutionService,
- private var blueprintTemplateService: BluePrintTemplateService,
+ private var blueprintTemplateService: BlueprintTemplateService,
private var resourceResolutionDBService: ResourceResolutionDBService
) :
ResourceResolutionService {
}
override suspend fun resolveFromDatabase(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
artifactTemplate: String,
resolutionKey: String
): String {
}
override suspend fun resolveResources(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
nodeTemplateName: String,
artifactNames: List<String>,
properties: Map<String, Any>
// The following error message is returned by default to handle a scenario when
// error message comes empty even when resolution has actually failed.
// Example: input-source type resolution seems to fail with no error code.
- bluePrintRuntimeService.getBluePrintError().errors.add("Failed to resolve required resources($failedResolution)")
- bluePrintRuntimeService.getBluePrintError().errors.addAll(resourceAssignmentRuntimeService.getBluePrintError().errors)
+ bluePrintRuntimeService.getBlueprintError().errors.add("Failed to resolve required resources($failedResolution)")
+ bluePrintRuntimeService.getBlueprintError().errors.addAll(resourceAssignmentRuntimeService.getBlueprintError().errors)
}
}
return ResourceResolutionResult(templateMap, assignmentMap)
}
override suspend fun resolveResources(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
nodeTemplateName: String,
artifactPrefix: String,
properties: Map<String, Any>
val resourceAssignments: MutableList<ResourceAssignment> =
JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment::class.java)
as? MutableList<ResourceAssignment>
- ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")
+ ?: throw BlueprintProcessorException("couldn't get Dictionary Definitions")
if (isToStore(properties)) {
val existingResourceResolution = isNewResolution(bluePrintRuntimeService, properties, artifactPrefix)
}
override suspend fun resolveResourceDefinition(
- blueprintRuntimeService: BluePrintRuntimeService<*>,
+ blueprintRuntimeService: BlueprintRuntimeService<*>,
resourceDefinitions: MutableMap<String, ResourceDefinition>,
resolveDefinition: String,
sources: List<String>
* request.
*/
override suspend fun resolveResourceAssignments(
- blueprintRuntimeService: BluePrintRuntimeService<*>,
+ blueprintRuntimeService: BlueprintRuntimeService<*>,
resourceDefinitions: MutableMap<String, ResourceDefinition>,
resourceAssignments: MutableList<ResourceAssignment>,
artifactPrefix: String,
// Execute Non Dependent Assignments in parallel ( ie asynchronously )
val deferred = batchResourceAssignments
.filter { it.name != "*" && it.name != "start" }
- .filter { it.status != BluePrintConstants.STATUS_SUCCESS }
+ .filter { it.status != BlueprintConstants.STATUS_SUCCESS }
.map { resourceAssignment ->
async {
val dictionaryName = resourceAssignment.dictionaryName
val resourceAssignmentProcessor =
applicationContext.getBean(processorName) as? ResourceAssignmentProcessor
- ?: throw BluePrintProcessorException(
+ ?: throw BlueprintProcessorException(
"failed to get resource processor ($processorName) " +
"for resource assignment(${resourceAssignment.name})"
)
try {
- // Set BluePrint Runtime Service
+ // Set Blueprint Runtime Service
resourceAssignmentProcessor.raRuntimeService = resourceAssignmentRuntimeService
// Set Resource Dictionaries
resourceAssignmentProcessor.resourceDictionaries = resourceDefinitions
}
// Set errors from RA
- blueprintRuntimeService.setBluePrintError(resourceAssignmentRuntimeService.getBluePrintError())
+ blueprintRuntimeService.setBlueprintError(resourceAssignmentRuntimeService.getBlueprintError())
} catch (e: RuntimeException) {
log.error("Fail in processing ${resourceAssignment.name}", e)
- throw BluePrintProcessorException(e)
+ throw BlueprintProcessorException(e)
}
}
}
}
else -> {
val resourceDefinition = resourceDefinitions[dictionaryName]
- ?: throw BluePrintProcessorException("couldn't get resource dictionary definition for $dictionaryName")
+ ?: throw BlueprintProcessorException("couldn't get resource dictionary definition for $dictionaryName")
val resourceSource = resourceDefinition.sources[dictionarySource]
- ?: throw BluePrintProcessorException("couldn't get resource definition $dictionaryName source($dictionarySource)")
+ ?: throw BlueprintProcessorException("couldn't get resource definition $dictionaryName source($dictionarySource)")
ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR.plus(resourceSource.type)
}
// Check whether resolution already exist in the database for the specified resolution-key or resourceId/resourceType
private suspend fun isNewResolution(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
properties: Map<String, Any>,
artifactPrefix: String
): List<ResourceResolution> {
resourceAssignmentList: MutableList<ResourceAssignment>
) {
resourceResolutionList.forEach { resourceResolution ->
- if (resourceResolution.status == BluePrintConstants.STATUS_SUCCESS) {
+ if (resourceResolution.status == BlueprintConstants.STATUS_SUCCESS) {
resourceAssignmentList.forEach {
if (compareOne(resourceResolution, it)) {
log.info(
import com.fasterxml.jackson.databind.JsonNode
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentScriptExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.nodeType
import kotlin.reflect.KClass
-fun BluePrintTypes.nodeTypeSourceInput(): NodeType {
+fun BlueprintTypes.nodeTypeSourceInput(): NodeType {
return nodeType(
- id = "source-input", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
+ id = "source-input", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
description = "This is Input Resource Source Node Type"
) {}
}
-fun BluePrintTypes.nodeTypeSourceDefault(): NodeType {
+fun BlueprintTypes.nodeTypeSourceDefault(): NodeType {
return nodeType(
- id = "source-default", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
+ id = "source-default", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
description = "This is Default Resource Source Node Type"
) {}
}
-fun BluePrintTypes.nodeTypeSourceDb(): NodeType {
+fun BlueprintTypes.nodeTypeSourceDb(): NodeType {
return nodeType(
- id = "source-db", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
+ id = "source-db", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
description = "This is Database Resource Source Node Type"
) {
property(
- "type", BluePrintConstants.DATA_TYPE_STRING,
+ "type", BlueprintConstants.DATA_TYPE_STRING,
true, ""
) {
defaultValue("SQL".asJsonPrimitive())
}
}
property(
- "endpoint-selector", BluePrintConstants.DATA_TYPE_STRING,
+ "endpoint-selector", BlueprintConstants.DATA_TYPE_STRING,
false, ""
)
property(
- "query", BluePrintConstants.DATA_TYPE_STRING,
+ "query", BlueprintConstants.DATA_TYPE_STRING,
true, ""
)
property(
- "input-key-mapping", BluePrintConstants.DATA_TYPE_MAP,
+ "input-key-mapping", BlueprintConstants.DATA_TYPE_MAP,
true, ""
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
property(
- "output-key-mapping", BluePrintConstants.DATA_TYPE_MAP,
+ "output-key-mapping", BlueprintConstants.DATA_TYPE_MAP,
false, ""
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
property(
- "key-dependencies", BluePrintConstants.DATA_TYPE_LIST,
+ "key-dependencies", BlueprintConstants.DATA_TYPE_LIST,
true, "Resource Resolution dependency dictionary names."
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
}
}
-fun BluePrintTypes.nodeTypeSourceRest(): NodeType {
+fun BlueprintTypes.nodeTypeSourceRest(): NodeType {
return nodeType(
- id = "source-rest", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
+ id = "source-rest", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
description = "This is Rest Resource Source Node Type"
) {
property(
- "type", BluePrintConstants.DATA_TYPE_STRING,
+ "type", BlueprintConstants.DATA_TYPE_STRING,
true, ""
) {
defaultValue("JSON".asJsonPrimitive())
}
}
property(
- "verb", BluePrintConstants.DATA_TYPE_STRING,
+ "verb", BlueprintConstants.DATA_TYPE_STRING,
true, ""
) {
defaultValue("GET".asJsonPrimitive())
}
}
property(
- "payload", BluePrintConstants.DATA_TYPE_STRING,
+ "payload", BlueprintConstants.DATA_TYPE_STRING,
false, ""
) {
defaultValue("".asJsonPrimitive())
}
property(
- "endpoint-selector", BluePrintConstants.DATA_TYPE_STRING,
+ "endpoint-selector", BlueprintConstants.DATA_TYPE_STRING,
false, ""
)
property(
- "url-path", BluePrintConstants.DATA_TYPE_STRING,
+ "url-path", BlueprintConstants.DATA_TYPE_STRING,
true, ""
)
property(
- "path", BluePrintConstants.DATA_TYPE_STRING,
+ "path", BlueprintConstants.DATA_TYPE_STRING,
true, ""
)
property(
- "expression-type", BluePrintConstants.DATA_TYPE_STRING,
+ "expression-type", BlueprintConstants.DATA_TYPE_STRING,
false, ""
) {
defaultValue("JSON_PATH".asJsonPrimitive())
}
}
property(
- "input-key-mapping", BluePrintConstants.DATA_TYPE_MAP,
+ "input-key-mapping", BlueprintConstants.DATA_TYPE_MAP,
true, ""
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
property(
- "output-key-mapping", BluePrintConstants.DATA_TYPE_MAP,
+ "output-key-mapping", BlueprintConstants.DATA_TYPE_MAP,
false, ""
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
property(
- "key-dependencies", BluePrintConstants.DATA_TYPE_LIST,
+ "key-dependencies", BlueprintConstants.DATA_TYPE_LIST,
true, "Resource Resolution dependency dictionary names."
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
}
}
-fun BluePrintTypes.nodeTypeSourceCapability(): NodeType {
+fun BlueprintTypes.nodeTypeSourceCapability(): NodeType {
return nodeType(
- id = "source-capability", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
+ id = "source-capability", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
description = "This is Component Resource Source Node Type"
) {
property(
- ComponentScriptExecutor.INPUT_SCRIPT_TYPE, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentScriptExecutor.INPUT_SCRIPT_TYPE, BlueprintConstants.DATA_TYPE_STRING,
true, "Request Id, Unique Id for the request."
) {
- defaultValue(BluePrintConstants.SCRIPT_KOTLIN)
+ defaultValue(BlueprintConstants.SCRIPT_KOTLIN)
constrain {
validValues(
arrayListOf(
- BluePrintConstants.SCRIPT_KOTLIN.asJsonPrimitive(),
- BluePrintConstants.SCRIPT_INTERNAL.asJsonPrimitive(),
- BluePrintConstants.SCRIPT_JYTHON.asJsonPrimitive()
+ BlueprintConstants.SCRIPT_KOTLIN.asJsonPrimitive(),
+ BlueprintConstants.SCRIPT_INTERNAL.asJsonPrimitive(),
+ BlueprintConstants.SCRIPT_JYTHON.asJsonPrimitive()
)
)
}
}
property(
- ComponentScriptExecutor.INPUT_SCRIPT_CLASS_REFERENCE, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentScriptExecutor.INPUT_SCRIPT_CLASS_REFERENCE, BlueprintConstants.DATA_TYPE_STRING,
true, "Kotlin Script class name or jython script name."
)
property(
- "key-dependencies", BluePrintConstants.DATA_TYPE_LIST,
+ "key-dependencies", BlueprintConstants.DATA_TYPE_LIST,
true, "Resource Resolution dependency dictionary names."
) {
- entrySchema(BluePrintConstants.DATA_TYPE_STRING)
+ entrySchema(BlueprintConstants.DATA_TYPE_STRING)
}
}
}
/** Node Template Source Input **/
-fun BluePrintTypes.nodeTemplateSourceInput(
+fun BlueprintTypes.nodeTemplateSourceInput(
id: String,
description: String,
block: SourceInputNodeTemplateBuilder.() -> Unit
)
/** Node Template Source Default **/
-fun BluePrintTypes.nodeTemplateSourceDefault(
+fun BlueprintTypes.nodeTemplateSourceDefault(
id: String,
description: String,
block: SourceDefaultNodeTemplateBuilder.() -> Unit
)
/** Node Template Source DB **/
-fun BluePrintTypes.nodeTemplateSourceDb(
+fun BlueprintTypes.nodeTemplateSourceDb(
id: String,
description: String,
block: SourceDbNodeTemplateBuilder.() -> Unit
}
/** Node Template Source Rest **/
-fun BluePrintTypes.nodeTemplateSourceRest(
+fun BlueprintTypes.nodeTemplateSourceRest(
id: String,
description: String,
block: SourceRestNodeTemplateBuilder.() -> Unit
}
/** Node Template Source Rest **/
-fun BluePrintTypes.nodeTemplateSourceCapability(
+fun BlueprintTypes.nodeTemplateSourceCapability(
id: String,
description: String,
block: SourceCapabilityNodeTemplateBuilder.() -> Unit
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.blueprintsprocessor.rest.restClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.KeyIdentifier
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
/** Check Resource Assignment has the source definitions, If not get from Resource Definitions **/
val resourceSource = resourceAssignment.dictionarySourceDefinition
?: resourceDefinition?.sources?.get(dSource)
- ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+ ?: throw BlueprintProcessorException("couldn't get resource definition $dName source($dSource)")
val resourceSourceProperties =
checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
resourceSourceProperties["resolved-payload"] = JacksonUtils.jsonNode(generatedPayload)
// Get the Rest Client service, selector will be included in application.properties
- val restClientService = BluePrintDependencyService.restClientService(
+ val restClientService = BlueprintDependencyService.restClientService(
"ipassign-ms"
)
"Failed to dictionary name ($dName), dictionary source($($dName) " +
"response_code: ($responseStatusCode)"
log.warn(errMsg)
- throw BluePrintProcessorException(errMsg)
+ throw BlueprintProcessorException(errMsg)
}
// Parse the error Body and assign the property value
}
ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
} catch (e: Exception) {
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Failed in template key ($resourceAssignment) assignments with: ${e.message}",
e
)
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ResourceAssignment) {
- raRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ raRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
/** Generates aggregated request payload for Ip Assign mS. Parses the resourceassignments of
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.blueprintsprocessor.rest.restClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.KeyIdentifier
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
/** Check Resource Assignment has the source definitions, If not get from Resource Definitions **/
val resourceSource = resourceAssignment.dictionarySourceDefinition
?: resourceDefinition?.sources?.get(dSource)
- ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+ ?: throw BlueprintProcessorException("couldn't get resource definition $dName source($dSource)")
val resourceSourceProperties =
checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
resourceSourceProperties["resolved-payload"] = JacksonUtils.jsonNode(generatedPayload)
// Get the Rest Client service, selector will be included in application.properties
- val restClientService = BluePrintDependencyService.restClientService(
+ val restClientService = BlueprintDependencyService.restClientService(
"naming-ms"
)
"Failed to dictionary name ($dName), dictionary source($($dName) " +
"response_code: ($responseStatusCode)"
log.warn(errMsg)
- throw BluePrintProcessorException(errMsg)
+ throw BlueprintProcessorException(errMsg)
}
// Parse the error Body and assign the property value
}
ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
} catch (e: Exception) {
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Failed in template key ($resourceAssignment) assignments with: ${e.message}",
e
)
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ResourceAssignment) {
- raRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ raRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
/** Generates aggregated request payload for Naming mS. Parses the resourceassignments of
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.slf4j.LoggerFactory
private val log = LoggerFactory.getLogger(ResourceResolutionDBService::class.toString())
suspend fun findByBlueprintNameAndBlueprintVersionAndArtifactNameAndResolutionKeyAndOccurrence(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
key: String,
occurrence: Int,
artifactPrefix: String
return try {
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- val blueprintVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]!!
- val blueprintName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]!!
+ val blueprintVersion = metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION]!!
+ val blueprintName = metadata[BlueprintConstants.METADATA_TEMPLATE_NAME]!!
resourceResolutionRepository.findByBlueprintNameAndBlueprintVersionAndArtifactNameAndResolutionKeyAndOccurrence(
blueprintName,
}
suspend fun findByBlueprintNameAndBlueprintVersionAndArtifactNameAndResourceIdAndResourceTypeAndOccurrence(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
resourceId: String,
resourceType: String,
occurrence: Int,
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- val blueprintVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]!!
- val blueprintName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]!!
+ val blueprintVersion = metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION]!!
+ val blueprintName = metadata[BlueprintConstants.METADATA_TEMPLATE_NAME]!!
resourceResolutionRepository.findByBlueprintNameAndBlueprintVersionAndArtifactNameAndResourceIdAndResourceTypeAndOccurrence(
blueprintName,
suspend fun write(
properties: Map<String, Any>,
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
artifactPrefix: String,
resourceAssignment: ResourceAssignment
): ResourceResolution = withContext(Dispatchers.IO) {
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- val blueprintVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]!!
- val blueprintName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]!!
+ val blueprintVersion = metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION]!!
+ val blueprintName = metadata[BlueprintConstants.METADATA_TEMPLATE_NAME]!!
val resolutionKey = properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOLUTION_KEY] as String
val resourceId = properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOURCE_ID] as String
resourceResolution.resourceType = resourceType
resourceResolution.resourceId = resourceId
resourceResolution.value = resourceAssignment.property?.value?.let {
- if (BluePrintConstants.STATUS_SUCCESS == resourceAssignment.status)
+ if (BlueprintConstants.STATUS_SUCCESS == resourceAssignment.status)
JacksonUtils.getValue(it).toString()
else ""
} ?: ""
resourceResolution.dictionaryName = resourceAssignment.dictionaryName
resourceResolution.dictionaryVersion = resourceAssignment.version
resourceResolution.dictionarySource = resourceAssignment.dictionarySource
- resourceResolution.status = resourceAssignment.status ?: BluePrintConstants.STATUS_FAILURE
+ resourceResolution.status = resourceAssignment.status ?: BlueprintConstants.STATUS_FAILURE
try {
resourceResolutionRepository.saveAndFlush(resourceResolution)
} catch (ex: Exception) {
- throw BluePrintException("Failed to store resource resolution result.", ex)
+ throw BlueprintException("Failed to store resource resolution result.", ex)
}
}
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.dao.EmptyResultDataAccessException
private val log = LoggerFactory.getLogger(TemplateResolutionService::class.toString())
suspend fun findByResolutionKeyAndBlueprintNameAndBlueprintVersionAndArtifactName(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
artifactPrefix: String,
resolutionKey: String
): String =
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- val blueprintVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]!!
- val blueprintName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]!!
+ val blueprintVersion = metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION]!!
+ val blueprintName = metadata[BlueprintConstants.METADATA_TEMPLATE_NAME]!!
findByResolutionKeyAndBlueprintNameAndBlueprintVersionAndArtifactName(
blueprintName,
suspend fun write(
properties: Map<String, Any>,
result: String,
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
artifactPrefix: String
): TemplateResolution = withContext(Dispatchers.IO) {
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- val blueprintVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]!!
- val blueprintName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]!!
+ val blueprintVersion = metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION]!!
+ val blueprintName = metadata[BlueprintConstants.METADATA_TEMPLATE_NAME]!!
val resolutionKey = properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOLUTION_KEY] as String
val resourceId = properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOURCE_ID] as String
val resourceType = properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOURCE_TYPE] as String
" (resourceId: $resourceId resourceType: $resourceType) occurrence:$occurrence error: {}",
ex.message
)
- throw BluePrintException("Failed to store resource api result.", ex)
+ throw BlueprintException("Failed to store resource api result.", ex)
}
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.slf4j.LoggerFactory
/** Check Resource Assignment has the source definitions, If not get from Resource Definition **/
val resourceSource = resourceAssignment.dictionarySourceDefinition
?: resourceDefinition?.sources?.get(dSource)
- ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+ ?: throw BlueprintProcessorException("couldn't get resource definition $dName source($dSource)")
val resourceSourceProps =
checkNotNull(resourceSource.properties) { "failed to get $resourceSource properties" }
}
override suspend fun recoverNB(runtimeException: RuntimeException, resourceAssignment: ResourceAssignment) {
- raRuntimeService.getBluePrintError()
+ raRuntimeService.getBlueprintError()
.addError("Failed in CapabilityResourceResolutionProcessor : ${runtimeException.message}")
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, runtimeException.message)
}
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibGenericService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibGenericService
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDBLibGenericService
-import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.BluePrintDBLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.BlueprintDBLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.DatabaseResourceSource
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ExecutionServiceDomains
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.isNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.nullToEmpty
@Service("${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-db")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
open class DatabaseResourceAssignmentProcessor(
- private val bluePrintDBLibPropertyService: BluePrintDBLibPropertyService,
+ private val bluePrintDBLibPropertyService: BlueprintDBLibPropertyService,
private val primaryDBLibGenericService: PrimaryDBLibGenericService
) : ResourceAssignmentProcessor() {
}
// Check the value has populated for mandatory case
ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Failed to process Database resource resolution in template key ($resourceAssignment) assignments."
throw e.updateErrorMessage(
ExecutionServiceDomains.RESOURCE_RESOLUTION, errorMsg,
)
} catch (e: Exception) {
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
- throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
+ throw BlueprintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
}
}
/** Check Resource Assignment has the source definitions, If not get from Resource Definition **/
val resourceSource = resourceAssignment.dictionarySourceDefinition
?: resourceDefinition?.sources?.get(dSource)
- ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+ ?: throw BlueprintProcessorException("couldn't get resource definition $dName source($dSource)")
val resourceSourceProperties = checkNotNull(resourceSource.properties) {
"failed to get source properties for $dName "
}
}
}
- private fun blueprintDBLibService(sourceProperties: DatabaseResourceSource, selector: String): BluePrintDBLibGenericService {
+ private fun blueprintDBLibService(sourceProperties: DatabaseResourceSource, selector: String): BlueprintDBLibGenericService {
return if (isNotEmpty(sourceProperties.endpointSelector)) {
val dbPropertiesJson = raRuntimeService.resolveDSLExpression(sourceProperties.endpointSelector!!)
bluePrintDBLibPropertyService.JdbcTemplate(dbPropertiesJson)
}
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
private fun validate(resourceAssignment: ResourceAssignment) {
checkNotEmpty(resourceAssignment.name) { "resource assignment template key is not defined" }
checkNotEmpty(resourceAssignment.dictionaryName) {
return namedParameters
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
private fun populateResource(
resourceAssignment: ResourceAssignment,
sourceProperties: DatabaseResourceSource,
}
override suspend fun recoverNB(runtimeException: RuntimeException, resourceAssignment: ResourceAssignment) {
- raRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ raRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ExecutionServiceDomains
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.updateErrorMessage
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.slf4j.LoggerFactory
}
// Check the value has populated for mandatory case
ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Failed to process default resource resolution in template key ($resourceAssignment) assignments."
throw e.updateErrorMessage(
ExecutionServiceDomains.RESOURCE_RESOLUTION, errorMsg,
)
} catch (e: Exception) {
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
- throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
+ throw BlueprintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
}
}
override suspend fun recoverNB(runtimeException: RuntimeException, resourceAssignment: ResourceAssignment) {
- raRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ raRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.DatabaseResourceSource
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.isNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
}
// Check the value has populated for mandatory case
ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Failed to process input resource resolution in template key ($resourceAssignment) assignments."
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
logger.error(errorMsg)
} catch (e: Exception) {
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
- throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with : (${e.message})", e)
+ throw BlueprintProcessorException("Failed in template key ($resourceAssignment) assignments with : (${e.message})", e)
}
}
/** Check Resource Assignment has the source definitions, If not get from Resource Definition **/
val resourceSource = resourceAssignment.dictionarySourceDefinition
?: resourceDefinition?.sources?.get(dSource)
- ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+ ?: throw BlueprintProcessorException("couldn't get resource definition $dName source($dSource)")
try {
val resourceSourceProperties = checkNotNull(resourceSource.properties) {
// keyDependency = service-instance.service-instance-id
setFromInputKeyDependencies(keyDependency, resourceAssignment); // New API which picks attribute from Input
} catch (e: IllegalStateException) {
- throw BluePrintProcessorException(e)
+ throw BlueprintProcessorException(e)
}
}
override suspend fun recoverNB(runtimeException: RuntimeException, resourceAssignment: ResourceAssignment) {
- raRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ raRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
}
import org.apache.commons.collections.MapUtils
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintFunctionNode
import org.onap.ccsdk.cds.controllerblueprints.core.isNullOrMissing
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintVelocityTemplateService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintVelocityTemplateService
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.slf4j.LoggerFactory
*/
open fun <T> scriptPropertyInstanceType(name: String): T {
return scriptPropertyInstances as? T
- ?: throw BluePrintProcessorException("couldn't get script property instance ($name)")
+ ?: throw BlueprintProcessorException("couldn't get script property instance ($name)")
}
open fun setFromInput(resourceAssignment: ResourceAssignment): Boolean {
ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, value)
return true
}
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
// NoOp - couldn't find value from input
}
return false
return true
}
}
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
// NoOp - couldn't find value from input
}
return false
return valueToResolve
}
// TODO("Optimize to JSON Node directly without velocity").asJsonNode().toString()
- return BluePrintVelocityTemplateService.generateContent(valueToResolve, keyMapping.asJsonNode().toString())
+ return BlueprintVelocityTemplateService.generateContent(valueToResolve, keyMapping.asJsonNode().toString())
}
final override suspend fun applyNB(resourceAssignment: ResourceAssignment): Boolean {
suspend fun executeScript(resourceAssignment: ResourceAssignment) {
return when (scriptType) {
- BluePrintConstants.SCRIPT_JYTHON -> {
+ BlueprintConstants.SCRIPT_JYTHON -> {
executeScriptBlocking(resourceAssignment)
}
else -> {
*/
final override fun apply(resourceAssignment: ResourceAssignment): Boolean {
- throw BluePrintException("Not Implemented, use applyNB method")
+ throw BlueprintException("Not Implemented, use applyNB method")
}
final override fun prepareRequest(resourceAssignment: ResourceAssignment): ResourceAssignment {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
final override fun prepareResponse(): Boolean {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
final override suspend fun prepareRequestNB(resourceAssignment: ResourceAssignment): ResourceAssignment {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
final override suspend fun prepareResponseNB(): Boolean {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
override fun process(resourceAssignment: ResourceAssignment) {
- throw BluePrintException("Not Implemented, child class will implement this")
+ throw BlueprintException("Not Implemented, child class will implement this")
}
override fun recover(runtimeException: RuntimeException, resourceAssignment: ResourceAssignment) {
- throw BluePrintException("Not Implemented, child class will implement this")
+ throw BlueprintException("Not Implemented, child class will implement this")
}
fun addError(type: String, name: String, error: String) {
- raRuntimeService.getBluePrintError().addError(type, name, error)
+ raRuntimeService.getBlueprintError().addError(type, name, error)
}
fun addError(error: String) {
- raRuntimeService.getBluePrintError().addError(error)
+ raRuntimeService.getBlueprintError().addError(error)
}
fun isTemplateKeyValueNull(resourceAssignment: ResourceAssignment): Boolean {
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.RestResourceSource
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ExecutionServiceDomains
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.isNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.nullToEmpty
*/
@Service("${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-rest")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyService: BluePrintRestLibPropertyService) :
+open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyService: BlueprintRestLibPropertyService) :
ResourceAssignmentProcessor() {
private val logger = LoggerFactory.getLogger(RestResourceResolutionProcessor::class.java)
/** Check Resource Assignment has the source definitions, If not get from Resource Definitions **/
val resourceSource = resourceAssignment.dictionarySourceDefinition
?: resourceDefinition?.sources?.get(dSource)
- ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+ ?: throw BlueprintProcessorException("couldn't get resource definition $dName source($dSource)")
val resourceSourceProperties =
checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
val responseBody = response.body
val outputKeyMapping = sourceProperties.outputKeyMapping
if (responseStatusCode in 200..299 && outputKeyMapping.isNullOrEmpty()) {
- resourceAssignment.status = BluePrintConstants.STATUS_SUCCESS
+ resourceAssignment.status = BlueprintConstants.STATUS_SUCCESS
logger.info("AS>> outputKeyMapping==null, will not populateResource")
} else if (responseStatusCode in 200..299 && !responseBody.isBlank()) {
populateResource(resourceAssignment, sourceProperties, responseBody, path)
val errMsg =
"Failed to get $dSource result for dictionary name ($dName) using urlPath ($urlPath) response_code: ($responseStatusCode)"
logger.warn(errMsg)
- throw BluePrintProcessorException(errMsg)
+ throw BlueprintProcessorException(errMsg)
}
}
// Check the value has populated for mandatory case
ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Failed to process REST resource resolution in template key ($resourceAssignment) assignments."
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, errorMsg)
throw e.updateErrorMessage(
)
} catch (e: Exception) {
ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
- throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
+ throw BlueprintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
}
}
}
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
private fun populateResource(
resourceAssignment: ResourceAssignment,
sourceProperties: RestResourceSource,
ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, parsedResponseNode)
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
private fun validate(resourceAssignment: ResourceAssignment) {
checkNotEmpty(resourceAssignment.name) { "resource assignment template key is not defined" }
checkNotEmpty(resourceAssignment.dictionaryName) {
}
override suspend fun recoverNB(runtimeException: RuntimeException, resourceAssignment: ResourceAssignment) {
- raRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ raRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
}
import com.fasterxml.jackson.databind.node.TextNode
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.checkFileExists
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.nullToEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.rootFieldsToMap
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintVelocityTemplateService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintVelocityTemplateService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonReactorUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.PropertyDefinitionUtils.Companion.hasLogProtect
suspend fun resourceDefinitions(blueprintBasePath: String): MutableMap<String, ResourceDefinition> {
val dictionaryFile = normalizedFile(
- blueprintBasePath, BluePrintConstants.TOSCA_DEFINITIONS_DIR,
+ blueprintBasePath, BlueprintConstants.TOSCA_DEFINITIONS_DIR,
ResourceResolutionConstants.FILE_NAME_RESOURCE_DEFINITION_TYPES
)
checkFileExists(dictionaryFile) { "resource definition file(${dictionaryFile.absolutePath}) is missing" }
return JacksonReactorUtils.getMapFromFile(dictionaryFile, ResourceDefinition::class.java)
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun setResourceDataValue(
resourceAssignment: ResourceAssignment,
raRuntimeService: ResourceAssignmentRuntimeService,
return setResourceDataValue(resourceAssignment, raRuntimeService, value.asJsonType())
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun setResourceDataValue(
resourceAssignment: ResourceAssignment,
raRuntimeService: ResourceAssignmentRuntimeService,
)
setResourceValue(resourceAssignment, raRuntimeService, value)
resourceAssignment.updatedDate = Date()
- resourceAssignment.updatedBy = BluePrintConstants.USER_SYSTEM
- resourceAssignment.status = BluePrintConstants.STATUS_SUCCESS
+ resourceAssignment.updatedBy = BlueprintConstants.USER_SYSTEM
+ resourceAssignment.status = BlueprintConstants.STATUS_SUCCESS
}
} catch (e: Exception) {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Failed in setting value for template key " +
"(${resourceAssignment.name}) and dictionary key (${resourceAssignment.dictionaryName}) of " +
"type (${resourceProp.type}) with error message (${e.message})",
.mapValues { e -> e.value.asText() } as MutableMap<String, Any>
val newValue: JsonNode
try {
- newValue = BluePrintVelocityTemplateService
+ newValue = BlueprintVelocityTemplateService
.generateContent(template, null, true, resolutionStore)
.also {
if (hasLogProtect(metadata))
}
.let { v -> v.asJsonType() }
} catch (e: Exception) {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"transform-template failed: $template", e
)
}
fun setFailedResourceDataValue(resourceAssignment: ResourceAssignment, message: String?) {
if (isNotEmpty(resourceAssignment.name)) {
resourceAssignment.updatedDate = Date()
- resourceAssignment.updatedBy = BluePrintConstants.USER_SYSTEM
- resourceAssignment.status = BluePrintConstants.STATUS_FAILURE
+ resourceAssignment.updatedBy = BlueprintConstants.USER_SYSTEM
+ resourceAssignment.status = BlueprintConstants.STATUS_FAILURE
resourceAssignment.message = message
}
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun assertTemplateKeyValueNotNull(resourceAssignment: ResourceAssignment) {
val resourceProp = checkNotNull(resourceAssignment.property) {
"Failed to populate mandatory resource resource mapping $resourceAssignment"
}
if (resourceProp.required != null && resourceProp.required!! && resourceProp.value.isNullOrMissing()) {
logger.error("failed to populate mandatory resource mapping ($resourceAssignment)")
- throw BluePrintProcessorException("failed to populate mandatory resource mapping ($resourceAssignment)")
+ throw BlueprintProcessorException("failed to populate mandatory resource mapping ($resourceAssignment)")
}
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun generateResourceDataForAssignments(assignments: List<ResourceAssignment>): String {
val result: String
try {
logger.info("Generated Resource Param Data ($result)")
}
} catch (e: Exception) {
- throw BluePrintProcessorException("Resource Assignment is failed with $e.message", e)
+ throw BlueprintProcessorException("Resource Assignment is failed with $e.message", e)
}
return result
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun generateResourceForAssignments(assignments: List<ResourceAssignment>): MutableMap<String, JsonNode> {
val data: MutableMap<String, JsonNode> = hashMapOf()
assignments.forEach {
}
fun transformToRARuntimeService(
- blueprintRuntimeService: BluePrintRuntimeService<*>,
+ blueprintRuntimeService: BlueprintRuntimeService<*>,
templateArtifactName: String
): ResourceAssignmentRuntimeService {
return resourceAssignmentRuntimeService
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun getPropertyType(
raRuntimeService: ResourceAssignmentRuntimeService,
dataTypeName: String,
logger.trace("Data type({})'s property ({}) is ({})", dataTypeName, propertyName, type)
} catch (e: Exception) {
logger.error("couldn't get data type($dataTypeName)'s property ($propertyName), error message $e")
- throw BluePrintProcessorException("${e.message}", e)
+ throw BlueprintProcessorException("${e.message}", e)
}
return type
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun parseResponseNode(
responseNode: JsonNode,
resourceAssignment: ResourceAssignment,
val metadata = resourceAssignment.property!!.metadata
try {
if ((resourceAssignment.property?.type).isNullOrEmpty()) {
- throw BluePrintProcessorException("Couldn't get data dictionary type for dictionary name (${resourceAssignment.name})")
+ throw BlueprintProcessorException("Couldn't get data dictionary type for dictionary name (${resourceAssignment.name})")
}
val type = resourceAssignment.property!!.type
val valueToPrint = getValueToLog(metadata, responseNode)
logger.info("For template key (${resourceAssignment.name}) trying to get value from responseNode ($valueToPrint)")
return when (type) {
- in BluePrintTypes.validPrimitiveTypes() -> {
+ in BlueprintTypes.validPrimitiveTypes() -> {
// Primitive Types
parseResponseNodeForPrimitiveTypes(responseNode, resourceAssignment, outputKeyMapping)
}
- in BluePrintTypes.validCollectionTypes() -> {
+ in BlueprintTypes.validCollectionTypes() -> {
// Array Types
parseResponseNodeForCollection(responseNode, resourceAssignment, raRuntimeService, outputKeyMapping)
}
}
} catch (e: Exception) {
logger.error("Fail to parse response data, error message $e")
- throw BluePrintProcessorException("${e.message}", e)
+ throw BlueprintProcessorException("${e.message}", e)
}
}
}
if (returnNode.isNullOrMissing() || returnNode!!.isComplexType() && !returnNode.has(outputKeyMapping[outputKey])) {
- throw BluePrintProcessorException("Fail to find output key mapping ($outputKey) in the responseNode.")
+ throw BlueprintProcessorException("Fail to find output key mapping ($outputKey) in the responseNode.")
}
val returnValue = if (returnNode.isComplexType()) {
val metadata = resourceAssignment.property!!.metadata
var resultNode: JsonNode
if ((resourceAssignment.property?.entrySchema?.type).isNullOrEmpty()) {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Couldn't get data type for dictionary type " +
"(${resourceAssignment.property!!.type}) and dictionary name ($dName)"
)
)
}
else -> {
- throw BluePrintProcessorException("Key-value response expected to match the responseNode.")
+ throw BlueprintProcessorException("Key-value response expected to match the responseNode.")
}
}
} else {
): ObjectNode {
val outputKeyMappingHasOnlyOneElement = checkIfOutputKeyMappingProvideOneElement(outputKeyMapping)
when (entrySchemaType) {
- in BluePrintTypes.validPrimitiveTypes() -> {
+ in BlueprintTypes.validPrimitiveTypes() -> {
if (outputKeyMappingHasOnlyOneElement) {
val outputKeyMap = outputKeyMapping.entries.first()
if (resourceAssignment.keyIdentifiers.none { it.name == outputKeyMap.key }) {
metadata
)
} else {
- throw BluePrintProcessorException("Expect one entry in output-key-mapping")
+ throw BlueprintProcessorException("Expect one entry in output-key-mapping")
}
}
else -> {
)
}
else -> {
- throw BluePrintProcessorException("Output-key-mapping do not map the Data Type $entrySchemaType")
+ throw BlueprintProcessorException("Output-key-mapping do not map the Data Type $entrySchemaType")
}
}
}
resourceAssignment.keyIdentifiers.add(KeyIdentifier(outputKeyMap.key, returnValue))
return returnValue
} else {
- throw BluePrintProcessorException("Output-key-mapping do not map the Data Type $entrySchemaType")
+ throw BlueprintProcessorException("Output-key-mapping do not map the Data Type $entrySchemaType")
}
}
)
}
else -> {
- throw BluePrintProcessorException("Output-key-mapping do not map the Data Type $entrySchemaType")
+ throw BlueprintProcessorException("Output-key-mapping do not map the Data Type $entrySchemaType")
}
}
} else {
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.asListOfString
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
MutableList<ResourceAssignment> {
/** Check if resolve definition is defined in the resource definition Map */
val resourceDefinition = resourceDefinitions[resolveDefinition]
- ?: throw BluePrintProcessorException("failed to get resolve definition($resolveDefinition)")
+ ?: throw BlueprintProcessorException("failed to get resolve definition($resolveDefinition)")
val resourceAssignments: MutableList<ResourceAssignment> = arrayListOf()
val definitionDependencies = definitionDependencies(resourceDefinition, sources)
definitionDependencies.forEach { definitionDependencyName ->
val definitionDependency = resourceDefinitions[definitionDependencyName]
- ?: throw BluePrintProcessorException("failed to get dependency definition($definitionDependencyName)")
+ ?: throw BlueprintProcessorException("failed to get dependency definition($definitionDependencyName)")
val resourceAssignment = ResourceAssignment().apply {
name = definitionDependency.name
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
@Test
fun testResourceDefinitionDSL() {
- val testResourceDefinition = BluePrintTypes.resourceDefinition(
+ val testResourceDefinition = BlueprintTypes.resourceDefinition(
"service-instance-id",
"VFW Service Instance Name"
) {
// println(resourceDefinition.asJsonString(true))
assertNotNull(testResourceDefinition, "failed to generate testResourceDefinition")
- val testResourceDefinitions = BluePrintTypes.resourceDefinitions {
+ val testResourceDefinitions = BlueprintTypes.resourceDefinitions {
resourceDefinition(testResourceDefinition)
}
assertNotNull(testResourceDefinitions, "failed to generate testResourceDefinitions")
@Test
fun testResourceAssignment() {
- val testResourceAssignment = BluePrintTypes.resourceAssignment(
+ val testResourceAssignment = BlueprintTypes.resourceAssignment(
"instance-name",
"service-instance-name", "odl-mdsal"
) {
// println(resourceAssignment.asJsonString(true))
assertNotNull(testResourceAssignment, "failed to generate resourceAssignment")
- val testResourceAssignments = BluePrintTypes.resourceAssignments {
+ val testResourceAssignments = BlueprintTypes.resourceAssignments {
resourceAssignment(testResourceAssignment)
resourceAssignment(
"instance-name1",
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.getAttribute
import kotlin.test.Test
import kotlin.test.assertNotNull
@Test
fun testNodeTypeComponentResourceResolution() {
- val nodeType = BluePrintTypes.nodeTypeComponentResourceResolution()
+ val nodeType = BlueprintTypes.nodeTypeComponentResourceResolution()
// println(nodeType.asJsonString(true))
assertNotNull(nodeType, "failed to generate nodeTypeComponentResourceResolution")
}
@Test
fun testNodeTemplateComponentResourceResolution() {
- val nodeTemplate = BluePrintTypes.nodeTemplateComponentResourceResolution("resource-resolve", "") {
+ val nodeTemplate = BlueprintTypes.nodeTemplateComponentResourceResolution("resource-resolve", "") {
definedOperation("Resolve resources") {
inputs {
actionName("resolve")
import org.junit.Before
import org.junit.Test
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import kotlin.test.assertEquals
import kotlin.test.fail
private val resourceType = "ServiceInstance"
private val occurrence = 1
private val props = mutableMapOf<String, JsonNode>()
- private val bluePrintRuntimeService = mockk<BluePrintRuntimeService<*>>()
+ private val bluePrintRuntimeService = mockk<BlueprintRuntimeService<*>>()
private val artifactNames = listOf("template")
private val nodeTemplateName = "nodeTemplateName"
runBlocking {
try {
resourceResolutionComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
assertEquals(
"Can't proceed with the resolution: either provide resolution-key OR combination of resource-id and resource-type.",
e.message
runBlocking {
try {
resourceResolutionComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
assertEquals(
"Can't proceed with the resolution: both resource-id and resource-type should be provided, one of them is missing.",
e.message
runBlocking {
try {
resourceResolutionComponent.processNB(executionRequest)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
assertEquals(
"Can't proceed with the resolution: can't persist resolution without a correlation key. " +
"Either provide a resolution-key OR combination of resource-id and resource-type OR set `storeResult` to false.",
@Test
fun testRecover() {
runBlocking {
- val blueprintError = BluePrintError()
+ val blueprintError = BlueprintError()
val exception = RuntimeException("message")
- every { bluePrintRuntimeService.getBluePrintError() } returns blueprintError
+ every { bluePrintRuntimeService.getBlueprintError() } returns blueprintError
resourceResolutionComponent.recoverNB(exception, executionRequest)
assertEquals(1, blueprintError.errors.size)
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor.MockCapabilityScriptRA
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResolutionSummary
import org.slf4j.LoggerFactory
Assert.assertNotNull("failed to create ResourceResolutionService", resourceResolutionService)
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
runBlocking {
Assert.assertNotNull("failed to create ResourceResolutionService", resourceResolutionService)
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
runBlocking {
Assert.assertNotNull("failed to create ResourceResolutionService", resourceResolutionService)
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
props[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOLUTION_SUMMARY] = true
Assert.assertNotNull("failed to create ResourceResolutionService", resourceResolutionService)
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
runBlocking {
Assert.assertNotNull("failed to create ResourceResolutionService", resourceResolutionService)
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
runBlocking {
Assert.assertNotNull("failed to create ResourceResolutionService", resourceResolutionService)
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
@Test
fun testResourceResolutionForDefinition() {
- val resourceDefinitions = BluePrintTypes.resourceDefinitions {
+ val resourceDefinitions = BlueprintTypes.resourceDefinitions {
resourceDefinition(name = "port-speed", description = "Port Speed") {
property(type = "string", required = true)
sources {
sourceCapability(id = "sdno", description = "SDNO Source") {
definedProperties {
- type(BluePrintConstants.SCRIPT_KOTLIN)
+ type(BlueprintConstants.SCRIPT_KOTLIN)
scriptClassReference(MockCapabilityScriptRA::class.qualifiedName!!)
keyDependencies(arrayListOf("device-id"))
}
}
runBlocking {
val raRuntimeService = mockk<ResourceAssignmentRuntimeService>()
- every { raRuntimeService.bluePrintContext() } returns mockk<BluePrintContext>()
- every { raRuntimeService.getBluePrintError() } returns BluePrintError()
- every { raRuntimeService.setBluePrintError(any()) } returns Unit
+ every { raRuntimeService.bluePrintContext() } returns mockk<BlueprintContext>()
+ every { raRuntimeService.getBlueprintError() } returns BlueprintError()
+ every { raRuntimeService.setBlueprintError(any()) } returns Unit
every { raRuntimeService.getInputValue("device-id") } returns "123456".asJsonPrimitive()
every { raRuntimeService.putResolutionStore(any(), any()) } returns Unit
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import kotlin.test.Test
import kotlin.test.assertNotNull
@Test
fun testNodeTypeSourceInput() {
- val nodeType = BluePrintTypes.nodeTypeSourceInput()
+ val nodeType = BlueprintTypes.nodeTypeSourceInput()
// println(nodeType.asJsonString(true))
assertNotNull(nodeType, "failed to generate nodeTypeSourceInput")
}
@Test
fun testNodeTypeSourceDefault() {
- val nodeType = BluePrintTypes.nodeTypeSourceDefault()
+ val nodeType = BlueprintTypes.nodeTypeSourceDefault()
// println(nodeType.asJsonString(true))
assertNotNull(nodeType, "failed to generate nodeTypeSourceDefault")
}
@Test
fun testNodeTypeSourceDb() {
- val nodeType = BluePrintTypes.nodeTypeSourceDb()
+ val nodeType = BlueprintTypes.nodeTypeSourceDb()
// println(nodeType.asJsonString(true))
assertNotNull(nodeType, "failed to generate nodeTypeSourceDb")
}
@Test
fun testNodeTypeSourceRest() {
- val nodeType = BluePrintTypes.nodeTypeSourceRest()
+ val nodeType = BlueprintTypes.nodeTypeSourceRest()
// println(nodeType.asJsonString(true))
assertNotNull(nodeType, "failed to generate nodeTypeSourceRest")
}
@Test
fun testNodeTypeSourceCapability() {
- val nodeType = BluePrintTypes.nodeTypeSourceCapability()
+ val nodeType = BlueprintTypes.nodeTypeSourceCapability()
// println(nodeType.asJsonString(true))
assertNotNull(nodeType, "failed to generate nodeTypeSourceCapability")
}
@Test
fun testNodeTemplateSourceInput() {
- val nodeTemplate = BluePrintTypes.nodeTemplateSourceInput("InputSystem", "") {
+ val nodeTemplate = BlueprintTypes.nodeTemplateSourceInput("InputSystem", "") {
}
// println(nodeTemplate.asJsonString(true))
assertNotNull(nodeTemplate, "failed to generate nodeTemplateSourceInput")
@Test
fun testNodeTemplateSourceDefault() {
- val nodeTemplate = BluePrintTypes.nodeTemplateSourceDefault("DefaultSystem", "") {
+ val nodeTemplate = BlueprintTypes.nodeTemplateSourceDefault("DefaultSystem", "") {
}
// println(nodeTemplate.asJsonString(true))
assertNotNull(nodeTemplate, "failed to generate nodeTemplateSourceDefault")
@Test
fun testNodeTemplateSourceDb() {
- val nodeTemplate = BluePrintTypes.nodeTemplateSourceDb("DbSystem", "") {
+ val nodeTemplate = BlueprintTypes.nodeTemplateSourceDb("DbSystem", "") {
definedProperties {
type("SQL")
query("SELECT * FROM DB WHERE name = \$name")
@Test
fun testNodeTemplateSourceRest() {
- val nodeTemplate = BluePrintTypes.nodeTemplateSourceRest("restSystem", "") {
+ val nodeTemplate = BlueprintTypes.nodeTemplateSourceRest("restSystem", "") {
definedProperties {
type("JSON")
endpointSelector("rest-source-endpoint")
@Test
fun testNodeTemplateSourceCapability() {
- val nodeTemplate = BluePrintTypes.nodeTemplateSourceCapability("capabiltySystem", "") {
+ val nodeTemplate = BlueprintTypes.nodeTemplateSourceCapability("capabiltySystem", "") {
definedProperties {
type("kotlin")
scriptClassReference("Scripts/Sample.kt")
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.PrimaryDatabaseConfiguration
import org.springframework.context.annotation.Bean
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = [
"org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution",
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.resourceAssignments
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.resourceDefinitions
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResolutionSummary
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
@Before
fun setup() {
- mockkObject(BluePrintDependencyService)
+ mockkObject(BlueprintDependencyService)
val blueprintWebClientService = mockk<BlueprintWebClientService>()
// Create mock Response
)
every { blueprintWebClientService.exchangeResource(any(), any(), any()) } returns mockResponse
- val restLibPropertyService = mockk<BluePrintRestLibPropertyService>()
+ val restLibPropertyService = mockk<BlueprintRestLibPropertyService>()
every { restLibPropertyService.blueprintWebClientService("ipassign-ms") } returns blueprintWebClientService
- every { BluePrintDependencyService.applicationContext.getBean(any()) } returns restLibPropertyService
+ every { BlueprintDependencyService.applicationContext.getBean(any()) } returns restLibPropertyService
}
@Test
/** Test dictionaries */
private fun resourceDefinitions(): MutableMap<String, ResourceDefinition> {
- return BluePrintTypes.resourceDefinitions {
+ return BlueprintTypes.resourceDefinitions {
resourceDefinition("CloudRegionId", "Cloud Region Id Resource Definition") {
tags("CloudRegionId")
updatedBy("saurav.paira@att.com")
}
private fun resourceAssignments(): MutableMap<String, ResourceAssignment> {
- return BluePrintTypes.resourceAssignments {
+ return BlueprintTypes.resourceAssignments {
resourceAssignment(
name = "CloudRegionId", dictionaryName = "CloudRegionId",
dictionarySource = "input"
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.resourceAssignments
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.resourceDefinitions
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResolutionSummary
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
@Before
fun setup() {
- mockkObject(BluePrintDependencyService)
+ mockkObject(BlueprintDependencyService)
val blueprintWebClientService = mockk<BlueprintWebClientService>()
// Create mock Response
)
every { blueprintWebClientService.exchangeResource(any(), any(), any()) } returns mockResponse
- val restLibPropertyService = mockk<BluePrintRestLibPropertyService>()
+ val restLibPropertyService = mockk<BlueprintRestLibPropertyService>()
every { restLibPropertyService.blueprintWebClientService("naming-ms") } returns blueprintWebClientService
- every { BluePrintDependencyService.applicationContext.getBean(any()) } returns restLibPropertyService
+ every { BlueprintDependencyService.applicationContext.getBean(any()) } returns restLibPropertyService
}
@Test
} returns NamingResolutionCapability()
val raRuntimeService = mockk<ResourceAssignmentRuntimeService>()
- every { raRuntimeService.getBluePrintError() } returns BluePrintError()
- every { raRuntimeService.bluePrintContext() } returns mockk<BluePrintContext>()
+ every { raRuntimeService.getBlueprintError() } returns BlueprintError()
+ every { raRuntimeService.bluePrintContext() } returns mockk<BlueprintContext>()
every { raRuntimeService.getInputValue("vf-module-name") } returns NullNode.getInstance()
every { raRuntimeService.getInputValue("vnfc-name") } returns NullNode.getInstance()
/** Test dictionaries */
private fun resourceDefinitions(): MutableMap<String, ResourceDefinition> {
- return BluePrintTypes.resourceDefinitions {
+ return BlueprintTypes.resourceDefinitions {
resourceDefinition("naming-code", "naming-code Resource Definition") {
tags("naming-code")
updatedBy("brindasanth@onap.com")
}
private fun resourceAssignments(): MutableMap<String, ResourceAssignment> {
- return BluePrintTypes.resourceAssignments {
+ return BlueprintTypes.resourceAssignments {
resourceAssignment(
name = "naming-code", dictionaryName = "naming-code",
dictionarySource = "input"
import org.junit.Before
import org.junit.Test
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.springframework.dao.EmptyResultDataAccessException
import kotlin.test.assertEquals
private val blueprintVersion = "1.0.0"
private val metadata = hashMapOf<String, String>()
private val props = hashMapOf<String, Any>()
- private val bluePrintContext = mockk<BluePrintContext>()
- private val bluePrintRuntimeService = mockk<DefaultBluePrintRuntimeService>()
+ private val bluePrintContext = mockk<BlueprintContext>()
+ private val bluePrintRuntimeService = mockk<DefaultBlueprintRuntimeService>()
@Before
fun setup() {
- metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION] = blueprintVersion
- metadata[BluePrintConstants.METADATA_TEMPLATE_NAME] = blueprintName
+ metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION] = blueprintVersion
+ metadata[BlueprintConstants.METADATA_TEMPLATE_NAME] = blueprintName
props[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOLUTION_KEY] = resolutionKey
props[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOURCE_ID] = resourceId
fun writeTest() {
val resourceResolution = ResourceResolution()
val resourceAssignment = ResourceAssignment()
- resourceAssignment.property?.status = BluePrintConstants.STATUS_SUCCESS
+ resourceAssignment.property?.status = BlueprintConstants.STATUS_SUCCESS
resourceAssignment.property?.value = "result".asJsonPrimitive()
resourceAssignment.dictionarySource = "ddSource"
resourceAssignment.dictionaryName = "ddName"
fun writeWithNullValue() {
val slot = slot<ResourceResolution>()
val resourceAssignment = ResourceAssignment()
- resourceAssignment.status = BluePrintConstants.STATUS_SUCCESS
+ resourceAssignment.status = BlueprintConstants.STATUS_SUCCESS
resourceAssignment.dictionarySource = "ddSource"
resourceAssignment.dictionaryName = "ddName"
resourceAssignment.version = 1
import org.junit.Before
import org.junit.Test
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.springframework.dao.EmptyResultDataAccessException
import kotlin.test.assertEquals
private val result = "result"
private val metadata = hashMapOf<String, String>()
private val props = hashMapOf<String, Any>()
- private val bluePrintContext = mockk<BluePrintContext>()
- private val bluePrintRuntimeService = mockk<DefaultBluePrintRuntimeService>()
+ private val bluePrintContext = mockk<BlueprintContext>()
+ private val bluePrintRuntimeService = mockk<DefaultBlueprintRuntimeService>()
@Before
fun setup() {
- metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION] = blueprintVersion
- metadata[BluePrintConstants.METADATA_TEMPLATE_NAME] = blueprintName
+ metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION] = blueprintVersion
+ metadata[BlueprintConstants.METADATA_TEMPLATE_NAME] = blueprintName
props[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOLUTION_KEY] = resolutionKey
props[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOURCE_ID] = resourceId
*/
package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.mock
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.RestClientProperties
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
-class MockBluePrintRestLibPropertyService(bluePrintProperties: BluePrintPropertiesService) :
- BluePrintRestLibPropertyService(bluePrintProperties) {
+class MockBlueprintRestLibPropertyService(bluePrintProperties: BlueprintPropertiesService) :
+ BlueprintRestLibPropertyService(bluePrintProperties) {
fun mockBlueprintWebClientService(selector: String):
MockBlueprintWebClientService {
import io.mockk.coEvery
import io.mockk.mockk
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibGenericService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibGenericService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
open class MockDBLibGenericService {
@Bean(name = ["MariaDatabaseConfiguration", "MySqlDatabaseConfiguration"])
- open fun createDatabaseConfiguration(): BluePrintDBLibGenericService {
- return mockk<BluePrintDBLibGenericService>()
+ open fun createDatabaseConfiguration(): BlueprintDBLibGenericService {
+ return mockk<BlueprintDBLibGenericService>()
}
}
open class MockBlueprintProcessorCatalogServiceImpl {
@Bean(name = ["bluePrintRuntimeValidatorService"])
- open fun bluePrintRuntimeValidatorService(): BluePrintValidatorService {
- val bluePrintValidatorService = mockk<BluePrintValidatorService>()
- coEvery { bluePrintValidatorService.validateBluePrints(any<String>()) } returns true
- coEvery { bluePrintValidatorService.validateBluePrints(any<BluePrintRuntimeService<*>>()) } returns true
+ open fun bluePrintRuntimeValidatorService(): BlueprintValidatorService {
+ val bluePrintValidatorService = mockk<BlueprintValidatorService>()
+ coEvery { bluePrintValidatorService.validateBlueprints(any<String>()) } returns true
+ coEvery { bluePrintValidatorService.validateBlueprints(any<BlueprintRuntimeService<*>>()) } returns true
return bluePrintValidatorService
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.RestResourceSource
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.nullToEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
class MockRestResourceResolutionProcessor(
private val blueprintRestLibPropertyService:
- MockBluePrintRestLibPropertyService
+ MockBlueprintRestLibPropertyService
) : ResourceAssignmentProcessor() {
private val logger = LoggerFactory.getLogger(MockRestResourceResolutionProcessor::class.java)
val errMsg =
"Failed to get $dSource result for dictionary name ($dName) using urlPath ($urlPath) response_code: ($responseStatusCode)"
logger.warn(errMsg)
- throw BluePrintProcessorException(errMsg)
+ throw BlueprintProcessorException(errMsg)
}
}
} catch (e: Exception) {
ResourceAssignmentUtils.setFailedResourceDataValue(executionRequest, e.message)
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Failed in template resolutionKey ($executionRequest) assignments with: ${e.message}",
e
)
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ResourceAssignment) {
- raRuntimeService.getBluePrintError().addError(runtimeException.message!!)
+ raRuntimeService.getBlueprintError().addError(runtimeException.message!!)
}
private fun blueprintWebClientService(resourceAssignment: ResourceAssignment): MockBlueprintWebClientService {
return blueprintRestLibPropertyService.mockBlueprintWebClientService(resourceAssignment.dictionarySource!!)
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
private fun populateResource(
resourceAssignment: ResourceAssignment,
sourceProperties: RestResourceSource,
val responseNode = JacksonUtils.jsonNode(restResponse).at(path)
when (type) {
- in BluePrintTypes.validPrimitiveTypes() -> {
+ in BlueprintTypes.validPrimitiveTypes() -> {
ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, responseNode)
}
- in BluePrintTypes.validCollectionTypes() -> {
+ in BlueprintTypes.validCollectionTypes() -> {
// Array Types
entrySchemaType = resourceAssignment.property!!.entrySchema!!.type
val arrayNode = responseNode as ArrayNode
- if (entrySchemaType !in BluePrintTypes.validPrimitiveTypes()) {
+ if (entrySchemaType !in BlueprintTypes.validPrimitiveTypes()) {
val responseArrayNode = responseNode.toList()
for (responseSingleJsonNode in responseArrayNode) {
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.resourceAssignment
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
} returns MockCapabilityScriptRA()
val raRuntimeService = mockk<ResourceAssignmentRuntimeService>()
- every { raRuntimeService.bluePrintContext() } returns mockk<BluePrintContext>()
+ every { raRuntimeService.bluePrintContext() } returns mockk<BlueprintContext>()
every { raRuntimeService.getInputValue("test-property") } returns NullNode.getInstance()
val capabilityResourceResolutionProcessor =
CapabilityResourceResolutionProcessor(componentFunctionScriptingService)
capabilityResourceResolutionProcessor.raRuntimeService = raRuntimeService
- val resourceAssignment = BluePrintTypes.resourceAssignment(
+ val resourceAssignment = BlueprintTypes.resourceAssignment(
name = "test-property", dictionaryName = "ra-dict-name",
dictionarySource = "capability"
) {
fun `test jython capability`() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/capability_python"
)
val componentFunctionScriptingService = mockk<ComponentFunctionScriptingService>()
coEvery {
componentFunctionScriptingService
- .scriptInstance<ResourceAssignmentProcessor>(any(), BluePrintConstants.SCRIPT_JYTHON, any())
+ .scriptInstance<ResourceAssignmentProcessor>(any(), BlueprintConstants.SCRIPT_JYTHON, any())
} returns MockCapabilityScriptRA()
val resourceAssignmentRuntimeService = ResourceAssignmentRuntimeService("1234", bluePrintContext)
import org.junit.Test
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDBLibGenericService
-import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.BluePrintDBLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.BlueprintDBLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.TestDatabaseConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.mock.MockBlueprintProcessorCatalogServiceImpl
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.mock.MockDBLibGenericService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
@ContextConfiguration(
classes = [
TestDatabaseConfiguration::class,
- PrimaryDBLibGenericService::class, BluePrintDBLibPropertyService::class,
+ PrimaryDBLibGenericService::class, BlueprintDBLibPropertyService::class,
DatabaseResourceAssignmentProcessor::class, MockDBLibGenericService::class,
MockBlueprintProcessorCatalogServiceImpl::class
]
@Test
fun `test database resource resolution processor db`() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
@Test
fun `test default resource resolution`() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
fun `InputResourceResolutionProcessor should be able to resolve a value for an input parameter`() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
-import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.mock.MockBluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.mock.MockBlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.mock.MockRestResourceResolutionProcessor
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
import org.onap.ccsdk.cds.blueprintsprocessor.rest.RestClientProperties
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- MockRestResourceResolutionProcessor::class, MockBluePrintRestLibPropertyService::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class, RestClientProperties::class
+ MockRestResourceResolutionProcessor::class, MockBlueprintRestLibPropertyService::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class, RestClientProperties::class
]
)
@TestPropertySource(locations = ["classpath:application-test.properties"])
class RestResourceResolutionProcessorTest {
@Autowired
- lateinit var bluePrintRestLibPropertyService: MockBluePrintRestLibPropertyService
+ lateinit var bluePrintRestLibPropertyService: MockBlueprintRestLibPropertyService
private lateinit var restResourceResolutionProcessor: MockRestResourceResolutionProcessor
@Test
fun `test rest resource resolution`() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
@Test
fun `test rest aai get resource resolution`() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
@Test
fun `test rest aai put resource resolution`() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
import org.onap.ccsdk.cds.controllerblueprints.core.data.EntrySchema
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
fun setup() {
val bluePrintContext = runBlocking {
- BluePrintMetadataUtils.getBluePrintContext(
+ BlueprintMetadataUtils.getBlueprintContext(
"./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
}
import org.onap.ccsdk.cds.blueprintsprocessor.rest.restClientService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintRetryException
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintRetryException
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
/**
* Register the Restconf module exposed dependency
val log = LoggerFactory.logger(AbstractScriptComponentFunction::class.java)!!
fun AbstractScriptComponentFunction.restconfClientService(selector: String): BlueprintWebClientService {
- return BluePrintDependencyService.restClientService(selector)
+ return BlueprintDependencyService.restClientService(selector)
}
/**
log.info("NF was mounted successfully on ODL")
result.body
} else {
- throw BluePrintRetryException("Wait for device($deviceId) to mount")
+ throw BlueprintRetryException("Wait for device($deviceId) to mount")
}
}
"PUT" -> log.info("sending PUT request, url: $requestUrl")
"PATCH" -> log.info("sending PATCH request, url: $requestUrl")
"POST" -> log.info("sending POST request, url: $requestUrl")
- else -> throw BluePrintProcessorException("Illegal request type, only POST, PUT or PATCH allowed.")
+ else -> throw BlueprintProcessorException("Illegal request type, only POST, PUT or PATCH allowed.")
}
return webClientService.exchangeResource(requestType, requestUrl, payload as String, headers)
}
when (requestType.toUpperCase()) {
"GET" -> log.info("sending GET request, url: $requestUrl")
"DELETE" -> log.info("sending DELETE request, url: $requestUrl")
- else -> throw BluePrintProcessorException("Illegal request type, only GET and DELETE allowed.")
+ else -> throw BlueprintProcessorException("Illegal request type, only GET and DELETE allowed.")
}
return webClientService.exchangeResource(requestType, requestUrl, "")
}
log.info("NF was mounted successfully on ODL")
result.body
} else {
- throw BluePrintRetryException("Wait for device with url($mountUrl) to mount")
+ throw BlueprintRetryException("Wait for device with url($mountUrl) to mount")
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentScriptExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.context.ApplicationContext
import kotlin.test.assertNotNull
payload = JacksonUtils.jsonNode("{}") as ObjectNode
}
- val blueprintContext = mockk<BluePrintContext>()
+ val blueprintContext = mockk<BlueprintContext>()
every {
blueprintContext.nodeTemplateOperationImplementation(
any(), any(), any()
)
} returns Implementation()
- val bluePrintRuntime = mockk<DefaultBluePrintRuntimeService>("1234")
+ val bluePrintRuntime = mockk<DefaultBlueprintRuntimeService>("1234")
every { bluePrintRuntime.bluePrintContext() } returns blueprintContext
componentScriptExecutor.bluePrintRuntimeService = bluePrintRuntime
componentScriptExecutor.stepName = "sample-step"
val operationInputs = hashMapOf<String, JsonNode>()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "activate-restconf".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_INTERFACE] = "interfaceName".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_OPERATION] = "operationName".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "activate-restconf".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_INTERFACE] = "interfaceName".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_OPERATION] = "operationName".asJsonPrimitive()
operationInputs[ComponentScriptExecutor.INPUT_SCRIPT_TYPE] =
- BluePrintConstants.SCRIPT_INTERNAL.asJsonPrimitive()
+ BlueprintConstants.SCRIPT_INTERNAL.asJsonPrimitive()
operationInputs[ComponentScriptExecutor.INPUT_SCRIPT_CLASS_REFERENCE] =
"internal.scripts.TestRestconfConfigure".asJsonPrimitive()
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError()
+ bluePrintRuntimeService.getBlueprintError()
.addError("Failed in ComponentRestfulExecutor : ${runtimeException.message}")
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.functions.restful.executor.nrmfunction.RestfulNRMServiceClient
import org.onap.ccsdk.cds.blueprintsprocessor.rest.RestLibConstants
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractScriptComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
private val log = LoggerFactory.getLogger(RestfulCMComponentFunction::class.java)
override suspend fun processNB(executionRequest: ExecutionServiceInput) {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
- open fun bluePrintRestLibPropertyService(): BluePrintRestLibPropertyService =
+ open fun bluePrintRestLibPropertyService(): BlueprintRestLibPropertyService =
functionDependencyInstanceAsType(RestLibConstants.SERVICE_BLUEPRINT_REST_LIB_PROPERTY)
fun restClientService(clientInfo: JsonNode): BlueprintWebClientService {
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.context.ApplicationContext
payload = JacksonUtils.jsonNode("{}") as ObjectNode
}
- val blueprintContext = mockk<BluePrintContext>()
+ val blueprintContext = mockk<BlueprintContext>()
every {
blueprintContext.nodeTemplateOperationImplementation(
any(), any(), any()
)
} returns Implementation()
- val bluePrintRuntime = mockk<DefaultBluePrintRuntimeService>("1234")
+ val bluePrintRuntime = mockk<DefaultBlueprintRuntimeService>("1234")
every { bluePrintRuntime.bluePrintContext() } returns blueprintContext
componentRestfulExecutor.bluePrintRuntimeService = bluePrintRuntime
componentRestfulExecutor.stepName = "sample-step"
val operationInputs = hashMapOf<String, JsonNode>()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "config-deploy-process".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_INTERFACE] = "interfaceName".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_OPERATION] = "operationName".asJsonPrimitive()
- operationInputs["script-type"] = BluePrintConstants.SCRIPT_INTERNAL.asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "config-deploy-process".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_INTERFACE] = "interfaceName".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_OPERATION] = "operationName".asJsonPrimitive()
+ operationInputs["script-type"] = BlueprintConstants.SCRIPT_INTERNAL.asJsonPrimitive()
operationInputs["script-class-reference"] = "internal.scripts.TestRestfulConfigure".asJsonPrimitive()
val stepInputData = StepData().apply {
import org.junit.Ignore
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.BluePrintRestLibConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.BlueprintRestLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
@RunWith(SpringRunner::class)
@EnableAutoConfiguration(exclude = [DataSourceAutoConfiguration::class])
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
-@ContextConfiguration(classes = [BluePrintRestLibConfiguration::class, NrmTestController::class])
+@ContextConfiguration(classes = [BlueprintRestLibConfiguration::class, NrmTestController::class])
@TestPropertySource(
properties = [
"blueprintsprocessor.restclient.nrm.type=basic-auth",
@Autowired
lateinit var restfulNRMServiceClient: RestfulNRMServiceClient
- lateinit var bluePrintRestLibPropertyService: BluePrintRestLibPropertyService
+ lateinit var bluePrintRestLibPropertyService: BlueprintRestLibPropertyService
@Test
fun testCreateMOI() {
+++ /dev/null
-/*
- * Copyright © 2017-2018 AT&T Intellectual Property.
- * Modifications Copyright © 2018 IBM.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.onap.ccsdk.cds.controllerblueprints.core
-
-import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
-
-/**
- *
- *
- * @author Brinda Santh
- */
-object BluePrintTypes {
-
- @JvmStatic
- val validNodeTypeDerivedFroms: MutableList<String> = arrayListOf(
- BluePrintConstants.MODEL_TYPE_NODES_ROOT,
- BluePrintConstants.MODEL_TYPE_NODE_WORKFLOW,
- BluePrintConstants.MODEL_TYPE_NODE_COMPONENT,
- BluePrintConstants.MODEL_TYPE_NODE_VNF,
- BluePrintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
- BluePrintConstants.MODEL_TYPE_NODES_COMPONENT_JAVA,
- BluePrintConstants.MODEL_TYPE_NODES_COMPONENT_BUNDLE,
- BluePrintConstants.MODEL_TYPE_NODES_COMPONENT_SCRIPT,
- BluePrintConstants.MODEL_TYPE_NODES_COMPONENT_PYTHON,
- BluePrintConstants.MODEL_TYPE_NODES_COMPONENT_JYTHON,
- BluePrintConstants.MODEL_TYPE_NODES_COMPONENT_JAVA_SCRIPT
- )
-
- @JvmStatic
- val validArtifactTypeDerivedFroms: MutableList<String> = arrayListOf(
- BluePrintConstants.MODEL_TYPE_ARTIFACTS_ROOT,
- BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION
- )
-
- @JvmStatic
- val validDataTypeDerivedFroms: MutableList<String> = arrayListOf(
- BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT,
- BluePrintConstants.MODEL_TYPE_DATA_TYPE_DYNAMIC
- )
-
- @JvmStatic
- val validRelationShipDerivedFroms: MutableList<String> = arrayListOf(
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_DEPENDS_ON,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_HOSTED_ON,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ATTACH_TO,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ROUTES_TO
- )
-
- @JvmStatic
- val validCapabilityTypes: MutableList<String> = arrayListOf(
- BluePrintConstants.MODEL_TYPE_CAPABILITIES_ROOT,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_NODE,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_COMPUTE,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_NETWORK,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_STORAGE,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT_PUBLIC,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT_ADMIN,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT_DATABASE,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ATTACHMENT,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_OPERATION_SYSTEM,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_BINDABLE,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_CONTENT,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_MAPPING,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_NETCONF,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_RESTCONF,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_SSH,
- BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_SFTP
- )
-
- @JvmStatic
- fun validModelTypes(): List<String> {
- val validTypes: MutableList<String> = arrayListOf()
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE)
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE)
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE)
- validTypes.add(BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE)
- return validTypes
- }
-
- @JvmStatic
- fun validPropertyTypes(): List<String> {
- val validTypes: MutableList<String> = arrayListOf()
- validTypes.addAll(validPrimitiveTypes())
- validTypes.addAll(validComplexTypes())
- validTypes.addAll(validCollectionTypes())
- return validTypes
- }
-
- @JvmStatic
- fun validPrimitiveTypes(): List<String> {
- val validTypes: MutableList<String> = arrayListOf()
- validTypes.add(BluePrintConstants.DATA_TYPE_STRING)
- validTypes.add(BluePrintConstants.DATA_TYPE_INTEGER)
- validTypes.add(BluePrintConstants.DATA_TYPE_FLOAT)
- validTypes.add(BluePrintConstants.DATA_TYPE_DOUBLE)
- validTypes.add(BluePrintConstants.DATA_TYPE_BOOLEAN)
- validTypes.add(BluePrintConstants.DATA_TYPE_TIMESTAMP)
- validTypes.add(BluePrintConstants.DATA_TYPE_NULL)
- return validTypes
- }
-
- @JvmStatic
- fun validComplexTypes(): List<String> {
- val validTypes: MutableList<String> = arrayListOf()
- validTypes.add(BluePrintConstants.DATA_TYPE_JSON)
- validTypes.add(BluePrintConstants.DATA_TYPE_MAP)
- return validTypes
- }
-
- @JvmStatic
- fun validCollectionTypes(): List<String> {
- val validTypes: MutableList<String> = arrayListOf()
- validTypes.add(BluePrintConstants.DATA_TYPE_LIST)
- return validTypes
- }
-
- @JvmStatic
- fun validPrimitiveOrCollectionPrimitive(propertyDefinition: PropertyDefinition): Boolean {
- val entrySchema = propertyDefinition.entrySchema?.type ?: BluePrintConstants.DATA_TYPE_NULL
- return BluePrintTypes.validPropertyTypes().contains(propertyDefinition.type) &&
- BluePrintTypes.validPrimitiveTypes().contains(entrySchema)
- }
-
- @JvmStatic
- fun validCommands(): List<String> {
- return listOf(
- BluePrintConstants.EXPRESSION_DSL_REFERENCE,
- BluePrintConstants.EXPRESSION_GET_INPUT,
- BluePrintConstants.EXPRESSION_GET_ATTRIBUTE,
- BluePrintConstants.EXPRESSION_GET_PROPERTY,
- BluePrintConstants.EXPRESSION_GET_ARTIFACT,
- BluePrintConstants.EXPRESSION_GET_OPERATION_OUTPUT,
- BluePrintConstants.EXPRESSION_GET_NODE_OF_TYPE
- )
- }
-
- @JvmStatic
- fun rootNodeTypes(): List<String> {
- return listOf(BluePrintConstants.MODEL_TYPE_NODES_ROOT)
- }
-
- @JvmStatic
- fun rootRelationshipTypes(): List<String> {
- return listOf(BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT)
- }
-
- @JvmStatic
- fun rootDataTypes(): List<String> {
- return listOf(BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT)
- }
-}
package org.onap.ccsdk.cds.controllerblueprints.core
/**
- * BluePrintConstants
+ * BlueprintConstants
*
* @author Brinda Santh
*/
-object BluePrintConstants {
+object BlueprintConstants {
val APP_NAME = System.getenv("APP_NAME")
?: "cds-controller"
package org.onap.ccsdk.cds.controllerblueprints.core
-class BluePrintError {
+class BlueprintError {
var errors: MutableList<String> = arrayListOf()
*
* @author Brinda Santh
*/
-class BluePrintException : BluePrintProcessorException {
+class BlueprintException : BlueprintProcessorException {
constructor(cause: Throwable) : super(cause)
constructor(message: String) : super(message)
import org.onap.ccsdk.cds.controllerblueprints.core.annotations.ArtifactExpression
import org.onap.ccsdk.cds.controllerblueprints.core.annotations.AttributeExpression
-import org.onap.ccsdk.cds.controllerblueprints.core.annotations.BluePrintsConstrain
-import org.onap.ccsdk.cds.controllerblueprints.core.annotations.BluePrintsDataType
-import org.onap.ccsdk.cds.controllerblueprints.core.annotations.BluePrintsProperty
+import org.onap.ccsdk.cds.controllerblueprints.core.annotations.BlueprintsConstrain
+import org.onap.ccsdk.cds.controllerblueprints.core.annotations.BlueprintsDataType
+import org.onap.ccsdk.cds.controllerblueprints.core.annotations.BlueprintsProperty
import org.onap.ccsdk.cds.controllerblueprints.core.annotations.DSLExpression
import org.onap.ccsdk.cds.controllerblueprints.core.annotations.InputExpression
import org.onap.ccsdk.cds.controllerblueprints.core.annotations.OperationOutputExpression
import kotlin.reflect.KType
import kotlin.reflect.full.declaredMemberProperties
-fun <T : KClass<*>> T.asBluePrintsDataTypes(): DataType {
- val annotation = this.annotations.filter { it is BluePrintsDataType }.single() as BluePrintsDataType
- checkNotNull(annotation) { "BluePrintsDataType annotation definition not found" }
+fun <T : KClass<*>> T.asBlueprintsDataTypes(): DataType {
+ val annotation = this.annotations.filter { it is BlueprintsDataType }.single() as BlueprintsDataType
+ checkNotNull(annotation) { "BlueprintsDataType annotation definition not found" }
val dataType = DataType().apply {
id = annotation.name
version = annotation.version
property.id = this.name
val getter = this.getter
property.required = !this.returnType.isMarkedNullable
- property.type = this.returnType.asBluePrintsDataType(this.name)
+ property.type = this.returnType.asBlueprintsDataType(this.name)
if (this.returnType.arguments.isNotEmpty()) {
property.entrySchema = this.returnType.entitySchema()
}
this.annotations.forEach { fieldAnnotation ->
// println("Field : ${this.name} : Annotation : $fieldAnnotation")
when (fieldAnnotation) {
- is BluePrintsProperty ->
+ is BlueprintsProperty ->
property.description = fieldAnnotation.description
is PropertyDefaultValue ->
property.value = fieldAnnotation.value.asJsonType(property.type)
- is BluePrintsConstrain -> {
+ is BlueprintsConstrain -> {
if (property.constraints == null) property.constraints = arrayListOf()
- property.constraints!!.add(fieldAnnotation.asBluePrintConstraintClause())
+ property.constraints!!.add(fieldAnnotation.asBlueprintConstraintClause())
}
is InputExpression -> {
property.value = getInput(fieldAnnotation.propertyName)
return property
}
-internal fun BluePrintsConstrain.asBluePrintConstraintClause(): ConstraintClause {
+internal fun BlueprintsConstrain.asBlueprintConstraintClause(): ConstraintClause {
TODO()
}
internal fun <T : KType> T.entitySchema(): EntrySchema {
val entrySchema = EntrySchema()
if (this.arguments.size == 1) {
- entrySchema.type = this.arguments[0].type!!.asBluePrintsDataType("")
+ entrySchema.type = this.arguments[0].type!!.asBlueprintsDataType("")
} else if (this.arguments.size == 2) {
- entrySchema.type = this.arguments[1].type!!.asBluePrintsDataType("")
+ entrySchema.type = this.arguments[1].type!!.asBlueprintsDataType("")
}
return entrySchema
}
-internal fun <T : KType> T.asBluePrintsDataType(propertyName: String): String {
+internal fun <T : KType> T.asBlueprintsDataType(propertyName: String): String {
val simpleName = (this.classifier as? KClass<*>)?.java?.simpleName
- ?: throw BluePrintException("filed to get simple name.")
+ ?: throw BlueprintException("filed to get simple name.")
return when (simpleName) {
- "String", "Date" -> BluePrintConstants.DATA_TYPE_STRING
- "int" -> BluePrintConstants.DATA_TYPE_INTEGER
- "Boolean" -> BluePrintConstants.DATA_TYPE_BOOLEAN
- "Float" -> BluePrintConstants.DATA_TYPE_FLOAT
- "Double" -> BluePrintConstants.DATA_TYPE_DOUBLE
- "List" -> BluePrintConstants.DATA_TYPE_LIST
- "Map" -> BluePrintConstants.DATA_TYPE_MAP
- "Object", "JsonNode", "ObjectNode", "ArrayNode" -> BluePrintConstants.DATA_TYPE_JSON
+ "String", "Date" -> BlueprintConstants.DATA_TYPE_STRING
+ "int" -> BlueprintConstants.DATA_TYPE_INTEGER
+ "Boolean" -> BlueprintConstants.DATA_TYPE_BOOLEAN
+ "Float" -> BlueprintConstants.DATA_TYPE_FLOAT
+ "Double" -> BlueprintConstants.DATA_TYPE_DOUBLE
+ "List" -> BlueprintConstants.DATA_TYPE_LIST
+ "Map" -> BlueprintConstants.DATA_TYPE_MAP
+ "Object", "JsonNode", "ObjectNode", "ArrayNode" -> BlueprintConstants.DATA_TYPE_JSON
else -> simpleName
}
}
*
* @author Brinda Santh
*/
-open class BluePrintProcessorException : ErrorCatalogException, ErrorCatalogExceptionFluent<BluePrintProcessorException> {
+open class BlueprintProcessorException : ErrorCatalogException, ErrorCatalogExceptionFluent<BlueprintProcessorException> {
constructor(message: String, cause: Throwable) : super(message, cause)
constructor(message: String) : super(message)
constructor(code: Int, message: String) : super(code, message)
constructor(code: Int, message: String, cause: Throwable) : super(code, message, cause)
- override fun code(code: Int): BluePrintProcessorException {
+ override fun code(code: Int): BlueprintProcessorException {
return this.updateCode(code)
}
- override fun domain(domain: String): BluePrintProcessorException {
+ override fun domain(domain: String): BlueprintProcessorException {
return this.updateDomain(domain)
}
- override fun action(action: String): BluePrintProcessorException {
+ override fun action(action: String): BlueprintProcessorException {
return this.updateAction(action)
}
- override fun http(type: String): BluePrintProcessorException {
+ override fun http(type: String): BlueprintProcessorException {
return this.updateHttp(type)
}
- override fun grpc(type: String): BluePrintProcessorException {
+ override fun grpc(type: String): BlueprintProcessorException {
return this.updateGrpc(type)
}
- override fun convertToHttp(): BluePrintProcessorException {
+ override fun convertToHttp(): BlueprintProcessorException {
return this.inverseToHttp()
}
- override fun convertToGrpc(): BluePrintProcessorException {
+ override fun convertToGrpc(): BlueprintProcessorException {
return this.inverseToHttp()
}
- override fun payloadMessage(message: String): BluePrintProcessorException {
+ override fun payloadMessage(message: String): BlueprintProcessorException {
return this.updatePayloadMessage(message)
}
- override fun addErrorPayloadMessage(message: String): BluePrintProcessorException {
+ override fun addErrorPayloadMessage(message: String): BlueprintProcessorException {
return this.updateErrorPayloadMessage(message)
}
- override fun addSubError(errorMessage: ErrorMessage): BluePrintProcessorException {
+ override fun addSubError(errorMessage: ErrorMessage): BlueprintProcessorException {
return this.updateSubError(errorMessage)
}
}
-class BluePrintRetryException : RuntimeException {
+class BlueprintRetryException : RuntimeException {
constructor(message: String, cause: Throwable) : super(message, cause)
constructor(message: String) : super(message)
constructor(cause: Throwable) : super(cause)
/** Extension Functions */
-fun processorException(message: String): BluePrintProcessorException {
- return BluePrintProcessorException(message)
+fun processorException(message: String): BlueprintProcessorException {
+ return BlueprintProcessorException(message)
}
-fun processorException(message: String, cause: Throwable): BluePrintProcessorException {
- return BluePrintProcessorException(message, cause)
+fun processorException(message: String, cause: Throwable): BlueprintProcessorException {
+ return BlueprintProcessorException(message, cause)
}
-fun processorException(cause: Throwable, message: String, vararg args: Any?): BluePrintProcessorException {
- return BluePrintProcessorException(cause, message, args)
+fun processorException(cause: Throwable, message: String, vararg args: Any?): BlueprintProcessorException {
+ return BlueprintProcessorException(cause, message, args)
}
-fun processorException(code: Int, message: String): BluePrintProcessorException {
+fun processorException(code: Int, message: String): BlueprintProcessorException {
return processorException(message).code(code)
}
-fun processorException(code: Int, message: String, cause: Throwable): BluePrintProcessorException {
+fun processorException(code: Int, message: String, cause: Throwable): BlueprintProcessorException {
return processorException(message, cause).code(code)
}
-fun processorException(code: Int, cause: Throwable, message: String, vararg args: Any?): BluePrintProcessorException {
+fun processorException(code: Int, cause: Throwable, message: String, vararg args: Any?): BlueprintProcessorException {
return processorException(cause, message, args).code(code)
}
-fun httpProcessorException(type: String, message: String): BluePrintProcessorException {
+fun httpProcessorException(type: String, message: String): BlueprintProcessorException {
return processorException(message).http(type)
}
-fun grpcProcessorException(type: String, message: String): BluePrintProcessorException {
+fun grpcProcessorException(type: String, message: String): BlueprintProcessorException {
return processorException(message).grpc(type)
}
-fun httpProcessorException(type: String, domain: String, message: String): BluePrintProcessorException {
+fun httpProcessorException(type: String, domain: String, message: String): BlueprintProcessorException {
val bluePrintProcessorException = processorException(message).http(type)
return bluePrintProcessorException.addDomainAndErrorMessage(domain, message)
}
-fun grpcProcessorException(type: String, domain: String, message: String): BluePrintProcessorException {
+fun grpcProcessorException(type: String, domain: String, message: String): BlueprintProcessorException {
val bluePrintProcessorException = processorException(message).grpc(type)
return bluePrintProcessorException.addDomainAndErrorMessage(domain, message)
}
fun httpProcessorException(type: String, domain: String, message: String, cause: Throwable):
- BluePrintProcessorException {
+ BlueprintProcessorException {
val bluePrintProcessorException = processorException(message, cause).http(type)
return bluePrintProcessorException.addDomainAndErrorMessage(domain, message, ExceptionUtils.getRootCauseMessage(cause))
}
fun grpcProcessorException(type: String, domain: String, message: String, cause: Throwable):
- BluePrintProcessorException {
+ BlueprintProcessorException {
val bluePrintProcessorException = processorException(message, cause).grpc(type)
return bluePrintProcessorException.addDomainAndErrorMessage(domain, message, ExceptionUtils.getRootCauseMessage(cause))
}
fun httpProcessorException(type: String, domain: String, message: String, cause: Throwable, vararg args: Any?):
- BluePrintProcessorException {
+ BlueprintProcessorException {
val bluePrintProcessorException = processorException(cause, message, args).http(type)
return bluePrintProcessorException.addDomainAndErrorMessage(domain, message, ExceptionUtils.getRootCauseMessage(cause))
}
fun grpcProcessorException(type: String, domain: String, message: String, cause: Throwable, vararg args: Any?):
- BluePrintProcessorException {
+ BlueprintProcessorException {
val bluePrintProcessorException = processorException(cause, message, args).grpc(type)
return bluePrintProcessorException.addDomainAndErrorMessage(domain, message, ExceptionUtils.getRootCauseMessage(cause))
}
-fun BluePrintProcessorException.updateErrorMessage(domain: String, message: String, cause: String):
- BluePrintProcessorException {
+fun BlueprintProcessorException.updateErrorMessage(domain: String, message: String, cause: String):
+ BlueprintProcessorException {
return this.addDomainAndErrorMessage(domain, message, cause).domain(domain)
.addErrorPayloadMessage(message)
.payloadMessage(message)
}
-fun BluePrintProcessorException.updateErrorMessage(domain: String, message: String): BluePrintProcessorException {
+fun BlueprintProcessorException.updateErrorMessage(domain: String, message: String): BlueprintProcessorException {
return this.addDomainAndErrorMessage(domain, message).domain(domain)
.addErrorPayloadMessage(message)
.payloadMessage(message)
}
-private fun BluePrintProcessorException.addDomainAndErrorMessage(
+private fun BlueprintProcessorException.addDomainAndErrorMessage(
domain: String,
message: String,
cause: String = ""
-): BluePrintProcessorException {
+): BlueprintProcessorException {
return this.addSubError(ErrorMessage(domain, message, cause)).domain(domain)
}
--- /dev/null
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2018 IBM.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.ccsdk.cds.controllerblueprints.core
+
+import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
+
+/**
+ *
+ *
+ * @author Brinda Santh
+ */
+object BlueprintTypes {
+
+ @JvmStatic
+ val validNodeTypeDerivedFroms: MutableList<String> = arrayListOf(
+ BlueprintConstants.MODEL_TYPE_NODES_ROOT,
+ BlueprintConstants.MODEL_TYPE_NODE_WORKFLOW,
+ BlueprintConstants.MODEL_TYPE_NODE_COMPONENT,
+ BlueprintConstants.MODEL_TYPE_NODE_VNF,
+ BlueprintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
+ BlueprintConstants.MODEL_TYPE_NODES_COMPONENT_JAVA,
+ BlueprintConstants.MODEL_TYPE_NODES_COMPONENT_BUNDLE,
+ BlueprintConstants.MODEL_TYPE_NODES_COMPONENT_SCRIPT,
+ BlueprintConstants.MODEL_TYPE_NODES_COMPONENT_PYTHON,
+ BlueprintConstants.MODEL_TYPE_NODES_COMPONENT_JYTHON,
+ BlueprintConstants.MODEL_TYPE_NODES_COMPONENT_JAVA_SCRIPT
+ )
+
+ @JvmStatic
+ val validArtifactTypeDerivedFroms: MutableList<String> = arrayListOf(
+ BlueprintConstants.MODEL_TYPE_ARTIFACTS_ROOT,
+ BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION
+ )
+
+ @JvmStatic
+ val validDataTypeDerivedFroms: MutableList<String> = arrayListOf(
+ BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT,
+ BlueprintConstants.MODEL_TYPE_DATA_TYPE_DYNAMIC
+ )
+
+ @JvmStatic
+ val validRelationShipDerivedFroms: MutableList<String> = arrayListOf(
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_DEPENDS_ON,
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_HOSTED_ON,
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_ATTACH_TO,
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_ROUTES_TO
+ )
+
+ @JvmStatic
+ val validCapabilityTypes: MutableList<String> = arrayListOf(
+ BlueprintConstants.MODEL_TYPE_CAPABILITIES_ROOT,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_NODE,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_COMPUTE,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_NETWORK,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_STORAGE,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT_PUBLIC,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT_ADMIN,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT_DATABASE,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ATTACHMENT,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_OPERATION_SYSTEM,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_BINDABLE,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_CONTENT,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_MAPPING,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_NETCONF,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_RESTCONF,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_SSH,
+ BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_SFTP
+ )
+
+ @JvmStatic
+ fun validModelTypes(): List<String> {
+ val validTypes: MutableList<String> = arrayListOf()
+ validTypes.add(BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
+ validTypes.add(BlueprintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE)
+ validTypes.add(BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE)
+ validTypes.add(BlueprintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE)
+ validTypes.add(BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE)
+ return validTypes
+ }
+
+ @JvmStatic
+ fun validPropertyTypes(): List<String> {
+ val validTypes: MutableList<String> = arrayListOf()
+ validTypes.addAll(validPrimitiveTypes())
+ validTypes.addAll(validComplexTypes())
+ validTypes.addAll(validCollectionTypes())
+ return validTypes
+ }
+
+ @JvmStatic
+ fun validPrimitiveTypes(): List<String> {
+ val validTypes: MutableList<String> = arrayListOf()
+ validTypes.add(BlueprintConstants.DATA_TYPE_STRING)
+ validTypes.add(BlueprintConstants.DATA_TYPE_INTEGER)
+ validTypes.add(BlueprintConstants.DATA_TYPE_FLOAT)
+ validTypes.add(BlueprintConstants.DATA_TYPE_DOUBLE)
+ validTypes.add(BlueprintConstants.DATA_TYPE_BOOLEAN)
+ validTypes.add(BlueprintConstants.DATA_TYPE_TIMESTAMP)
+ validTypes.add(BlueprintConstants.DATA_TYPE_NULL)
+ return validTypes
+ }
+
+ @JvmStatic
+ fun validComplexTypes(): List<String> {
+ val validTypes: MutableList<String> = arrayListOf()
+ validTypes.add(BlueprintConstants.DATA_TYPE_JSON)
+ validTypes.add(BlueprintConstants.DATA_TYPE_MAP)
+ return validTypes
+ }
+
+ @JvmStatic
+ fun validCollectionTypes(): List<String> {
+ val validTypes: MutableList<String> = arrayListOf()
+ validTypes.add(BlueprintConstants.DATA_TYPE_LIST)
+ return validTypes
+ }
+
+ @JvmStatic
+ fun validPrimitiveOrCollectionPrimitive(propertyDefinition: PropertyDefinition): Boolean {
+ val entrySchema = propertyDefinition.entrySchema?.type ?: BlueprintConstants.DATA_TYPE_NULL
+ return BlueprintTypes.validPropertyTypes().contains(propertyDefinition.type) &&
+ BlueprintTypes.validPrimitiveTypes().contains(entrySchema)
+ }
+
+ @JvmStatic
+ fun validCommands(): List<String> {
+ return listOf(
+ BlueprintConstants.EXPRESSION_DSL_REFERENCE,
+ BlueprintConstants.EXPRESSION_GET_INPUT,
+ BlueprintConstants.EXPRESSION_GET_ATTRIBUTE,
+ BlueprintConstants.EXPRESSION_GET_PROPERTY,
+ BlueprintConstants.EXPRESSION_GET_ARTIFACT,
+ BlueprintConstants.EXPRESSION_GET_OPERATION_OUTPUT,
+ BlueprintConstants.EXPRESSION_GET_NODE_OF_TYPE
+ )
+ }
+
+ @JvmStatic
+ fun rootNodeTypes(): List<String> {
+ return listOf(BlueprintConstants.MODEL_TYPE_NODES_ROOT)
+ }
+
+ @JvmStatic
+ fun rootRelationshipTypes(): List<String> {
+ return listOf(BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT)
+ }
+
+ @JvmStatic
+ fun rootDataTypes(): List<String> {
+ return listOf(BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT)
+ }
+}
is Double ->
this.asJsonPrimitive()
else ->
- throw BluePrintException("$this type is not supported")
+ throw BlueprintException("$this type is not supported")
}
}
}
/** Based on Blueprint DataType Convert string value to JsonNode Type **/
fun String.asJsonType(bpDataType: String): JsonNode {
return when (bpDataType.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_STRING -> this.asJsonPrimitive()
- BluePrintConstants.DATA_TYPE_BOOLEAN -> this.toBoolean().asJsonPrimitive()
- BluePrintConstants.DATA_TYPE_INTEGER -> this.toInt().asJsonPrimitive()
- BluePrintConstants.DATA_TYPE_FLOAT -> this.toFloat().asJsonPrimitive()
- BluePrintConstants.DATA_TYPE_DOUBLE -> this.toDouble().asJsonPrimitive()
+ BlueprintConstants.DATA_TYPE_STRING -> this.asJsonPrimitive()
+ BlueprintConstants.DATA_TYPE_BOOLEAN -> this.toBoolean().asJsonPrimitive()
+ BlueprintConstants.DATA_TYPE_INTEGER -> this.toInt().asJsonPrimitive()
+ BlueprintConstants.DATA_TYPE_FLOAT -> this.toFloat().asJsonPrimitive()
+ BlueprintConstants.DATA_TYPE_DOUBLE -> this.toDouble().asJsonPrimitive()
// For List, Map and Complex Types.
else -> this.jsonAsJsonType()
}
if (containsKey(key)) {
return get(key) as T
} else {
- throw BluePrintException("couldn't find the key $key")
+ throw BlueprintException("couldn't find the key $key")
}
}
fun <T> JsonNode.asType(clazzType: Class<T>): T {
return JacksonUtils.readValue(this, clazzType)
- ?: throw BluePrintException("couldn't convert JsonNode of type $clazzType")
+ ?: throw BlueprintException("couldn't convert JsonNode of type $clazzType")
}
fun JsonNode.asListOfString(): List<String> {
}
return propertyMap
} else {
- throw BluePrintException("json node should be Object Node Type")
+ throw BlueprintException("json node should be Object Node Type")
}
}
}
fun Map<String, JsonNode>.getAsString(key: String): String {
- return this[key]?.asText() ?: throw BluePrintException("couldn't find value for key($key)")
+ return this[key]?.asText() ?: throw BlueprintException("couldn't find value for key($key)")
}
fun Map<String, JsonNode>.getAsBoolean(key: String): Boolean {
- return this[key]?.asBoolean() ?: throw BluePrintException("couldn't find value for key($key)")
+ return this[key]?.asBoolean() ?: throw BlueprintException("couldn't find value for key($key)")
}
fun Map<String, JsonNode>.getAsInt(key: String): Int {
- return this[key]?.asInt() ?: throw BluePrintException("couldn't find value for key($key)")
+ return this[key]?.asInt() ?: throw BlueprintException("couldn't find value for key($key)")
}
fun Map<String, JsonNode>.getAsDouble(key: String): Double {
- return this[key]?.asDouble() ?: throw BluePrintException("couldn't find value for key($key)")
+ return this[key]?.asDouble() ?: throw BlueprintException("couldn't find value for key($key)")
}
fun Map<String, JsonNode>.getOptionalAsString(key: String): String? {
if (value1.equals(value2, ignoreCase = true)) {
return true
} else {
- throw BluePrintException(lazyMessage().toString())
+ throw BlueprintException(lazyMessage().toString())
}
}
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.apache.commons.io.FileUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils
import java.io.File
import java.io.InputStream
import java.nio.charset.Charset
// this.mkdirs()
FileUtils.forceMkdir(this)
check(this.exists()) {
- throw BluePrintException("failed to re create dir(${this.absolutePath})")
+ throw BlueprintException("failed to re create dir(${this.absolutePath})")
}
return this
}
* Compress the current Dir to the target zip file and return the target zip file
*/
fun File.compress(targetZipFile: File): File {
- BluePrintArchiveUtils.compress(this, targetZipFile)
+ BlueprintArchiveUtils.compress(this, targetZipFile)
return targetZipFile
}
* De-Compress the current zip file to the target file and return the target file
*/
fun File.deCompress(targetFile: File): File {
- BluePrintArchiveUtils.deCompress(this, targetFile.path)
+ BlueprintArchiveUtils.deCompress(this, targetFile.path)
return targetFile
}
package org.onap.ccsdk.cds.controllerblueprints.core.annotations
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import kotlin.reflect.KClass
@Target(AnnotationTarget.CLASS)
-annotation class BluePrintsDataType(
+annotation class BlueprintsDataType(
val name: String,
- val version: String = BluePrintConstants.DEFAULT_VERSION_NUMBER,
+ val version: String = BlueprintConstants.DEFAULT_VERSION_NUMBER,
val description: String,
val derivedFrom: String = "tosca.datatypes.root"
)
@Target(AnnotationTarget.CLASS)
-annotation class BluePrintsWorkflowInput
+annotation class BlueprintsWorkflowInput
@Target(AnnotationTarget.CLASS)
-annotation class BluePrintsWorkflowOutput
+annotation class BlueprintsWorkflowOutput
@Target(AnnotationTarget.CLASS)
-annotation class BluePrintsNodeType(
+annotation class BlueprintsNodeType(
val propertiesType: KClass<*>,
val attributesType: KClass<*>,
val inputsType: KClass<*>,
)
@Target(AnnotationTarget.FIELD, AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.PROPERTY)
-annotation class BluePrintsProperty(
+annotation class BlueprintsProperty(
val name: String = "",
val description: String = ""
)
@Target(AnnotationTarget.FIELD, AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.PROPERTY)
@Repeatable
-annotation class BluePrintsConstrain()
+annotation class BlueprintsConstrain()
@Target(AnnotationTarget.FIELD, AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.PROPERTY)
annotation class PropertyDefaultValue(val value: String)
package org.onap.ccsdk.cds.controllerblueprints.core.config
-open class BluePrintLoadConfiguration {
+open class BlueprintLoadConfiguration {
lateinit var blueprintDeployPath: String
lateinit var blueprintArchivePath: String
lateinit var blueprintWorkingPath: String
- var loadBluePrintPaths: String? = null
+ var loadBlueprintPaths: String? = null
var loadModeTypePaths: String? = null
var loadResourceDictionaryPaths: String? = null
}
import com.fasterxml.jackson.annotation.JsonPropertyOrder
import com.fasterxml.jackson.databind.JsonNode
import io.swagger.annotations.ApiModelProperty
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
/**
var dependencies: MutableList<String>? = null
@get:JsonProperty("operation_host")
- var operationHost: String = BluePrintConstants.PROPERTY_SELF
+ var operationHost: String = BlueprintConstants.PROPERTY_SELF
// Timeout value in seconds
var timeout: Int = 180
lateinit var templateName: String
lateinit var templateVersion: String
lateinit var templateTags: String
- var templateType: String = BluePrintConstants.BLUEPRINT_TYPE_DEFAULT
+ var templateType: String = BlueprintConstants.BLUEPRINT_TYPE_DEFAULT
}
package org.onap.ccsdk.cds.controllerblueprints.core.dsl
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
version: String,
author: String,
tags: String,
- block: DSLBluePrintBuilder.() -> Unit
-): DSLBluePrint {
- return DSLBluePrintBuilder(name, version, author, tags).apply(block).build()
+ block: DSLBlueprintBuilder.() -> Unit
+): DSLBlueprint {
+ return DSLBlueprintBuilder(name, version, author, tags).apply(block).build()
}
// TOSCA DSLs
/** Blueprint Type Extensions */
fun ServiceTemplateBuilder.nodeTypeComponent() {
- val nodeType = BluePrintTypes.nodeTypeComponent()
+ val nodeType = BlueprintTypes.nodeTypeComponent()
if (this.nodeTypes == null) this.nodeTypes = hashMapOf()
this.nodeTypes!![nodeType.id!!] = nodeType
}
-fun BluePrintTypes.nodeTypeComponent(): NodeType {
+fun BlueprintTypes.nodeTypeComponent(): NodeType {
return nodeType(
- id = BluePrintConstants.MODEL_TYPE_NODE_COMPONENT,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODES_ROOT,
+ id = BlueprintConstants.MODEL_TYPE_NODE_COMPONENT,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODES_ROOT,
description = "This is default Component Node"
) {
}
}
@Deprecated("CDS won't support, use implerative workflow definitions.")
-fun BluePrintTypes.nodeTypeWorkflow(): NodeType {
+fun BlueprintTypes.nodeTypeWorkflow(): NodeType {
return nodeType(
- id = BluePrintConstants.MODEL_TYPE_NODE_WORKFLOW,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODES_ROOT,
+ id = BlueprintConstants.MODEL_TYPE_NODE_WORKFLOW,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODES_ROOT,
description = "This is default Workflow Node"
) {
}
}
fun ServiceTemplateBuilder.nodeTypeVnf() {
- val nodeType = BluePrintTypes.nodeTypeVnf()
+ val nodeType = BlueprintTypes.nodeTypeVnf()
if (this.nodeTypes == null) this.nodeTypes = hashMapOf()
this.nodeTypes!![nodeType.id!!] = nodeType
}
-fun BluePrintTypes.nodeTypeVnf(): NodeType {
+fun BlueprintTypes.nodeTypeVnf(): NodeType {
return nodeType(
- id = BluePrintConstants.MODEL_TYPE_NODE_VNF,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODES_ROOT,
+ id = BlueprintConstants.MODEL_TYPE_NODE_VNF,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODES_ROOT,
description = "This is default VNF Node"
) {
}
}
fun ServiceTemplateBuilder.nodeTypeResourceSource() {
- val nodeType = BluePrintTypes.nodeTypeResourceSource()
+ val nodeType = BlueprintTypes.nodeTypeResourceSource()
if (this.nodeTypes == null) this.nodeTypes = hashMapOf()
this.nodeTypes!![nodeType.id!!] = nodeType
}
-fun BluePrintTypes.nodeTypeResourceSource(): NodeType {
+fun BlueprintTypes.nodeTypeResourceSource(): NodeType {
return nodeType(
- id = BluePrintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODES_ROOT,
+ id = BlueprintConstants.MODEL_TYPE_NODE_RESOURCE_SOURCE,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODES_ROOT,
description = "This is default Resource Source Node"
) {
}
/** Artifacts */
fun ServiceTemplateBuilder.artifactTypeTemplateVelocity() {
- val artifactType = BluePrintTypes.artifactTypeTemplateVelocity()
+ val artifactType = BlueprintTypes.artifactTypeTemplateVelocity()
if (this.artifactTypes == null) this.artifactTypes = hashMapOf()
this.artifactTypes!![artifactType.id!!] = artifactType
}
-fun BluePrintTypes.artifactTypeTemplateVelocity(): ArtifactType {
+fun BlueprintTypes.artifactTypeTemplateVelocity(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_VELOCITY,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_VELOCITY,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "Velocity Artifact"
) {
fileExt("vtl")
}
fun ServiceTemplateBuilder.artifactTypeTempleJinja() {
- val artifactType = BluePrintTypes.artifactTypeTempleJinja()
+ val artifactType = BlueprintTypes.artifactTypeTempleJinja()
if (this.artifactTypes == null) this.artifactTypes = hashMapOf()
this.artifactTypes!![artifactType.id!!] = artifactType
}
-fun BluePrintTypes.artifactTypeTempleJinja(): ArtifactType {
+fun BlueprintTypes.artifactTypeTempleJinja(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_JINJA,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_JINJA,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "Jinja Artifact"
) {
fileExt("jinja")
}
fun ServiceTemplateBuilder.artifactTypeMappingResource() {
- val artifactType = BluePrintTypes.artifactTypeMappingResource()
+ val artifactType = BlueprintTypes.artifactTypeMappingResource()
if (this.artifactTypes == null) this.artifactTypes = hashMapOf()
this.artifactTypes!![artifactType.id!!] = artifactType
}
-fun BluePrintTypes.artifactTypeMappingResource(): ArtifactType {
+fun BlueprintTypes.artifactTypeMappingResource(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_MAPPING_RESOURCE,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_MAPPING_RESOURCE,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "Mapping Resource Artifact"
) {
fileExt("json")
}
@Deprecated("CDS won't support", replaceWith = ReplaceWith("artifactTypeScriptKotlin"))
-fun BluePrintTypes.artifactTypeScriptJython(): ArtifactType {
+fun BlueprintTypes.artifactTypeScriptJython(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_SCRIPT_JYTHON,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_SCRIPT_JYTHON,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "Jython Script Artifact"
) {
fileExt("py")
}
fun ServiceTemplateBuilder.artifactTypeScriptKotlin() {
- val artifactType = BluePrintTypes.artifactTypeScriptKotlin()
+ val artifactType = BlueprintTypes.artifactTypeScriptKotlin()
if (this.artifactTypes == null) this.artifactTypes = hashMapOf()
this.artifactTypes!![artifactType.id!!] = artifactType
}
-fun BluePrintTypes.artifactTypeScriptKotlin(): ArtifactType {
+fun BlueprintTypes.artifactTypeScriptKotlin(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_SCRIPT_KOTLIN,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_SCRIPT_KOTLIN,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "Kotlin Script Artifact"
) {
fileExt("kts")
}
fun ServiceTemplateBuilder.artifactTypeK8sProfileFolder() {
- val artifactType = BluePrintTypes.artifactTypeK8sProfileFolder()
+ val artifactType = BlueprintTypes.artifactTypeK8sProfileFolder()
if (this.artifactTypes == null) this.artifactTypes = hashMapOf()
this.artifactTypes!![artifactType.id!!] = artifactType
}
-fun BluePrintTypes.artifactTypeK8sProfileFolder(): ArtifactType {
+fun BlueprintTypes.artifactTypeK8sProfileFolder(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_K8S_PROFILE,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_K8S_PROFILE,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "K8s Profile Folder Artifact"
) {
}
}
@Deprecated("CDS won't support, use implerative workflow definitions.")
-fun BluePrintTypes.artifactTypeDirectedGraph(): ArtifactType {
+fun BlueprintTypes.artifactTypeDirectedGraph(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_DIRECTED_GRAPH,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_DIRECTED_GRAPH,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "Directed Graph Artifact"
) {
fileExt("xml", "json")
}
fun ServiceTemplateBuilder.artifactTypeComponentJar() {
- val artifactType = BluePrintTypes.artifactTypeComponentJar()
+ val artifactType = BlueprintTypes.artifactTypeComponentJar()
if (this.artifactTypes == null) this.artifactTypes = hashMapOf()
this.artifactTypes!![artifactType.id!!] = artifactType
}
-fun BluePrintTypes.artifactTypeComponentJar(): ArtifactType {
+fun BlueprintTypes.artifactTypeComponentJar(): ArtifactType {
return artifactType(
- id = BluePrintConstants.MODEL_TYPE_ARTIFACT_COMPONENT_JAR,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
+ id = BlueprintConstants.MODEL_TYPE_ARTIFACT_COMPONENT_JAR,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_ARTIFACT_TYPE_IMPLEMENTATION,
description = "Component Artifact"
) {
fileExt("jar")
/** Relationship Types */
fun ServiceTemplateBuilder.relationshipTypeConnectsTo() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsTo()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsTo()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsTo(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsTo(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
description = "Relationship connects to"
) {
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
fun ServiceTemplateBuilder.relationshipTypeDependsOn() {
- val relationshipType = BluePrintTypes.relationshipTypeDependsOn()
+ val relationshipType = BlueprintTypes.relationshipTypeDependsOn()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeDependsOn(): RelationshipType {
+fun BlueprintTypes.relationshipTypeDependsOn(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_DEPENDS_ON,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_DEPENDS_ON,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
description = "Relationship depends on"
) {
}
}
fun ServiceTemplateBuilder.relationshipTypeHostedOn() {
- val relationshipType = BluePrintTypes.relationshipTypeHostedOn()
+ val relationshipType = BlueprintTypes.relationshipTypeHostedOn()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeHostedOn(): RelationshipType {
+fun BlueprintTypes.relationshipTypeHostedOn(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_HOSTED_ON,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_HOSTED_ON,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_ROOT,
description = "Relationship hosted on"
) {
}
package org.onap.ccsdk.cds.controllerblueprints.core.dsl
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
/**
* @author Brinda Santh
*/
-class DSLBluePrintBuilder(
+class DSLBlueprintBuilder(
private val name: String,
private val version: String,
private val author: String,
private val tags: String
) {
- private var dslBluePrint = DSLBluePrint()
+ private var dslBlueprint = DSLBlueprint()
private var metadata: MutableMap<String, String> = hashMapOf()
var properties: MutableMap<String, JsonNode>? = null
var dataTypes: MutableMap<String, DataType> = hashMapOf()
var workflows: MutableMap<String, DSLWorkflow> = hashMapOf()
private fun initMetaData() {
- metadata[BluePrintConstants.METADATA_TEMPLATE_NAME] = name
- metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION] = version
- metadata[BluePrintConstants.METADATA_TEMPLATE_AUTHOR] = author
- metadata[BluePrintConstants.METADATA_TEMPLATE_TAGS] = tags
+ metadata[BlueprintConstants.METADATA_TEMPLATE_NAME] = name
+ metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION] = version
+ metadata[BlueprintConstants.METADATA_TEMPLATE_AUTHOR] = author
+ metadata[BlueprintConstants.METADATA_TEMPLATE_TAGS] = tags
}
fun metadata(id: String, value: String) {
workflows[id] = DSLWorkflowBuilder(id, description).apply(block).build()
}
- fun build(): DSLBluePrint {
+ fun build(): DSLBlueprint {
initMetaData()
- dslBluePrint.metadata = metadata
- dslBluePrint.properties = properties
- dslBluePrint.dataTypes = dataTypes
- dslBluePrint.artifactTypes = artifactTypes
- dslBluePrint.components = components
- dslBluePrint.registryComponents = registryComponents
- dslBluePrint.workflows = workflows
- return dslBluePrint
+ dslBlueprint.metadata = metadata
+ dslBlueprint.properties = properties
+ dslBlueprint.dataTypes = dataTypes
+ dslBlueprint.artifactTypes = artifactTypes
+ dslBlueprint.components = components
+ dslBlueprint.registryComponents = registryComponents
+ dslBlueprint.workflows = workflows
+ return dslBlueprint
}
}
properties!![id] = property
}
- fun implementation(timeout: Int, operationHost: String? = BluePrintConstants.PROPERTY_SELF) {
+ fun implementation(timeout: Int, operationHost: String? = BlueprintConstants.PROPERTY_SELF) {
implementation = Implementation().apply {
this.operationHost = operationHost!!
this.timeout = timeout
properties!![id] = expression.asJsonType()
}
- fun implementation(timeout: Int, operationHost: String? = BluePrintConstants.PROPERTY_SELF) {
+ fun implementation(timeout: Int, operationHost: String? = BlueprintConstants.PROPERTY_SELF) {
implementation = Implementation().apply {
this.operationHost = operationHost!!
this.timeout = timeout
class DSLAttributeDefinitionBuilder(
private val id: String,
- private val type: String? = BluePrintConstants.DATA_TYPE_STRING,
+ private val type: String? = BlueprintConstants.DATA_TYPE_STRING,
private val required: Boolean? = false,
private val expression: JsonNode,
private val description: String? = ""
class DSLPropertyDefinitionBuilder(
private val id: String,
- private val type: String? = BluePrintConstants.DATA_TYPE_STRING,
+ private val type: String? = BlueprintConstants.DATA_TYPE_STRING,
private val required: Boolean? = false,
private val expression: JsonNode,
private val description: String? = ""
* @author Brinda Santh
*/
-class DSLBluePrint {
+class DSLBlueprint {
var metadata: MutableMap<String, String> = hashMapOf()
var properties: MutableMap<String, JsonNode>? = null
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.bpClone
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeDefinition
* Generate Service Template for the simplified DSL.
* @author Brinda Santh
*/
-class BluePrintServiceTemplateGenerator(private val dslBluePrint: DSLBluePrint) {
+class BlueprintServiceTemplateGenerator(private val dslBlueprint: DSLBlueprint) {
private var serviceTemplate = ServiceTemplate()
private val dataTypes: MutableMap<String, DataType> = hashMapOf()
fun serviceTemplate(): ServiceTemplate {
- serviceTemplate.metadata = dslBluePrint.metadata
- serviceTemplate.dslDefinitions = dslBluePrint.properties
+ serviceTemplate.metadata = dslBlueprint.metadata
+ serviceTemplate.dslDefinitions = dslBlueprint.properties
- dataTypes.putAll(dslBluePrint.dataTypes)
- artifactTypes.putAll(dslBluePrint.artifactTypes)
+ dataTypes.putAll(dslBlueprint.dataTypes)
+ artifactTypes.putAll(dslBlueprint.artifactTypes)
serviceTemplate.dataTypes = dataTypes
serviceTemplate.artifactTypes = artifactTypes
val nodeTemplates: MutableMap<String, NodeTemplate> = hashMapOf()
// For New or Dynamic Components
- val components = dslBluePrint.components
+ val components = dslBlueprint.components
components.forEach { (dslCompName, dslComp) ->
val nodeTemplate = NodeTemplate()
nodeTemplate.type = dslComp.type
}
// For Registry Components
- val registryComponents = dslBluePrint.registryComponents
+ val registryComponents = dslBlueprint.registryComponents
registryComponents.forEach { (dslCompName, dslComp) ->
val nodeTemplate = NodeTemplate()
nodeTemplate.type = dslComp.type
private fun populateWorkflow(): MutableMap<String, Workflow>? {
var workflows: MutableMap<String, Workflow>? = null
- if (dslBluePrint.workflows.isNotEmpty()) {
+ if (dslBlueprint.workflows.isNotEmpty()) {
workflows = hashMapOf()
- dslBluePrint.workflows.forEach { (dslWorkflowName, dslWorkflow) ->
+ dslBlueprint.workflows.forEach { (dslWorkflowName, dslWorkflow) ->
val workflow = Workflow()
workflow.description = dslWorkflow.description
workflow.steps = dslWorkflow.steps
private fun populateNodeType(dslComponent: DSLComponent): NodeType {
val nodeType = NodeType()
- nodeType.derivedFrom = BluePrintConstants.MODEL_TYPE_NODES_ROOT
+ nodeType.derivedFrom = BlueprintConstants.MODEL_TYPE_NODES_ROOT
nodeType.version = dslComponent.version
nodeType.description = dslComponent.description
nodeType.interfaces = populateInterfaceDefinitions(dslComponent, nodeType)
operationDefinition.outputs = propertyDefinitions(dslComponent.outputs)
val operations: MutableMap<String, OperationDefinition> = hashMapOf()
- operations[BluePrintConstants.DEFAULT_STEP_OPERATION] = operationDefinition
+ operations[BlueprintConstants.DEFAULT_STEP_OPERATION] = operationDefinition
val interfaceDefinition = InterfaceDefinition()
interfaceDefinition.operations = operations
val interfaces: MutableMap<String, InterfaceDefinition> = hashMapOf()
- interfaces[BluePrintConstants.DEFAULT_STEP_INTERFACE] = interfaceDefinition
+ interfaces[BlueprintConstants.DEFAULT_STEP_INTERFACE] = interfaceDefinition
return interfaces
}
operationAssignment.outputs = dslComponent.outputs
val operations: MutableMap<String, OperationAssignment> = hashMapOf()
- operations[BluePrintConstants.DEFAULT_STEP_OPERATION] = operationAssignment
+ operations[BlueprintConstants.DEFAULT_STEP_OPERATION] = operationAssignment
val interfaceAssignment = InterfaceAssignment()
interfaceAssignment.operations = operations
operationAssignment.outputs = propertyAssignments(dslComponent.outputs)
val operations: MutableMap<String, OperationAssignment> = hashMapOf()
- operations[BluePrintConstants.DEFAULT_STEP_OPERATION] = operationAssignment
+ operations[BlueprintConstants.DEFAULT_STEP_OPERATION] = operationAssignment
val interfaceAssignment = InterfaceAssignment()
interfaceAssignment.operations = operations
val interfaces: MutableMap<String, InterfaceAssignment> = hashMapOf()
- interfaces[BluePrintConstants.DEFAULT_STEP_INTERFACE] = interfaceAssignment
+ interfaces[BlueprintConstants.DEFAULT_STEP_INTERFACE] = interfaceAssignment
return interfaces
}
package org.onap.ccsdk.cds.controllerblueprints.core.dsl
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityAssignment
if (interfaces == null) interfaces = hashMapOf()
val interfaceAssignment = InterfaceAssignment()
- val defaultOperationName = BluePrintConstants.DEFAULT_STEP_OPERATION
+ val defaultOperationName = BlueprintConstants.DEFAULT_STEP_OPERATION
interfaceAssignment.operations = hashMapOf()
interfaceAssignment.operations!![defaultOperationName] =
OperationAssignmentBuilder<In, Out>(defaultOperationName, description).apply(block).build()
operationAssignment.implementation = implementation
}
- fun implementation(timeout: Int, operationHost: String? = BluePrintConstants.PROPERTY_SELF) {
+ fun implementation(timeout: Int, operationHost: String? = BlueprintConstants.PROPERTY_SELF) {
operationAssignment.implementation = Implementation().apply {
this.operationHost = operationHost!!
this.timeout = timeout
fun implementation(
timeout: Int,
- operationHost: String? = BluePrintConstants.PROPERTY_SELF,
+ operationHost: String? = BlueprintConstants.PROPERTY_SELF,
block: ImplementationBuilder.() -> Unit
) {
operationAssignment.implementation = ImplementationBuilder(timeout, operationHost!!).apply(block).build()
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.ArrayNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.asListOfString
private var capabilityDefinition = CapabilityDefinition()
private val properties: MutableMap<String, PropertyDefinition> = hashMapOf()
- fun property(id: String, type: String? = BluePrintConstants.DATA_TYPE_STRING, required: Boolean? = false, description: String? = "") {
+ fun property(id: String, type: String? = BlueprintConstants.DATA_TYPE_STRING, required: Boolean? = false, description: String? = "") {
val property = PropertyDefinitionBuilder(id, type, required, description).build()
properties[id] = property
}
class AttributeDefinitionBuilder(
private val id: String,
- private val type: String? = BluePrintConstants.DATA_TYPE_STRING,
+ private val type: String? = BlueprintConstants.DATA_TYPE_STRING,
private val required: Boolean? = false,
private val description: String? = ""
) {
class PropertyDefinitionBuilder(
private val id: String,
- private val type: String? = BluePrintConstants.DATA_TYPE_STRING,
+ private val type: String? = BlueprintConstants.DATA_TYPE_STRING,
private val required: Boolean? = false,
private val description: String? = ""
) {
package org.onap.ccsdk.cds.controllerblueprints.core.dsl
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asPropertyDefinitionMap
import org.onap.ccsdk.cds.controllerblueprints.core.data.Activity
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
step.id = id
step.target = target
// Add Default Activity, Assumption is only one Operation
- activity(".${BluePrintConstants.DEFAULT_STEP_OPERATION}")
+ activity(".${BlueprintConstants.DEFAULT_STEP_OPERATION}")
step.description = description
step.activities = activities
step.onSuccess = onSuccess
package org.onap.ccsdk.cds.controllerblueprints.core.dsl
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.asBluePrintsDataTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.asBlueprintsDataTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.asPropertyDefinitionMap
var policyTypes: MutableMap<String, PolicyType>? = null
private fun initMetaData() {
- metadata[BluePrintConstants.METADATA_TEMPLATE_NAME] = name
- metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION] = version
- metadata[BluePrintConstants.METADATA_TEMPLATE_AUTHOR] = author
- metadata[BluePrintConstants.METADATA_TEMPLATE_TAGS] = tags
+ metadata[BlueprintConstants.METADATA_TEMPLATE_NAME] = name
+ metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION] = version
+ metadata[BlueprintConstants.METADATA_TEMPLATE_AUTHOR] = author
+ metadata[BlueprintConstants.METADATA_TEMPLATE_TAGS] = tags
}
fun metadata(id: String, value: String) {
}
fun dataType(dataType: KClass<*>) {
- dataType(dataType.asBluePrintsDataTypes())
+ dataType(dataType.asBlueprintsDataTypes())
}
fun dsl(id: String, content: Any) {
package org.onap.ccsdk.cds.controllerblueprints.core.interfaces
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import java.io.File
import java.nio.file.Path
-interface BluePrintCatalogService {
+interface BlueprintCatalogService {
/**
* Save the CBA to database.
* @param blueprintFile Either a directory, or an archive
* @param validate whether to validate blueprint content. Default true.
* @return The unique blueprint identifier
- * @throws BluePrintException if process failed
+ * @throws BlueprintException if process failed
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun saveToDatabase(processingId: String, blueprintFile: File, validate: Boolean = true): String
/**
* @param version Version of the blueprint
* @param extract true to extract the content, false for archived content. Default to true
* @return Path where CBA is located
- * @throws BluePrintException if process failed
+ * @throws BlueprintException if process failed
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun getFromDatabase(name: String, version: String, extract: Boolean = true): Path
/**
* Delete the CBA from database.
* @param name Name of the blueprint
* @param version Version of the blueprint
- * @throws BluePrintException if process failed
+ * @throws BlueprintException if process failed
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun deleteFromDatabase(name: String, version: String)
}
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
-interface BluePrintDefinitions {
+interface BlueprintDefinitions {
/** Define the service Template Model */
fun serviceTemplate(): ServiceTemplate
fun otherDefinitions(): MutableMap<String, Any>
}
-abstract class AbstractBluePrintDefinitions : BluePrintDefinitions {
+abstract class AbstractBlueprintDefinitions : BlueprintDefinitions {
private val otherDefinitionMap: MutableMap<String, Any> = hashMapOf()
package org.onap.ccsdk.cds.controllerblueprints.core.interfaces
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
-interface BluePrintEnhancer<T> {
+interface BlueprintEnhancer<T> {
- fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: T)
+ fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, type: T)
}
-interface BluePrintServiceTemplateEnhancer : BluePrintEnhancer<ServiceTemplate>
+interface BlueprintServiceTemplateEnhancer : BlueprintEnhancer<ServiceTemplate>
-interface BluePrintTopologyTemplateEnhancer : BluePrintEnhancer<TopologyTemplate>
+interface BlueprintTopologyTemplateEnhancer : BlueprintEnhancer<TopologyTemplate>
-interface BluePrintWorkflowEnhancer : BluePrintEnhancer<Workflow>
+interface BlueprintWorkflowEnhancer : BlueprintEnhancer<Workflow>
-interface BluePrintNodeTemplateEnhancer : BluePrintEnhancer<NodeTemplate>
+interface BlueprintNodeTemplateEnhancer : BlueprintEnhancer<NodeTemplate>
-interface BluePrintNodeTypeEnhancer : BluePrintEnhancer<NodeType>
+interface BlueprintNodeTypeEnhancer : BlueprintEnhancer<NodeType>
-interface BluePrintRelationshipTemplateEnhancer : BluePrintEnhancer<RelationshipTemplate>
+interface BlueprintRelationshipTemplateEnhancer : BlueprintEnhancer<RelationshipTemplate>
-interface BluePrintRelationshipTypeEnhancer : BluePrintEnhancer<RelationshipType>
+interface BlueprintRelationshipTypeEnhancer : BlueprintEnhancer<RelationshipType>
-interface Blue
PrintArtifactDefinitionEnhancer : BluePrintEnhancer<ArtifactDefinition>
+interface Blue
printArtifactDefinitionEnhancer : BlueprintEnhancer<ArtifactDefinition>
-interface Blue
PrintPolicyTypeEnhancer : BluePrintEnhancer<PolicyType>
+interface Blue
printPolicyTypeEnhancer : BlueprintEnhancer<PolicyType>
-interface Blue
PrintPropertyDefinitionEnhancer : BluePrintEnhancer<PropertyDefinition>
+interface Blue
printPropertyDefinitionEnhancer : BlueprintEnhancer<PropertyDefinition>
-interface Blue
PrintAttributeDefinitionEnhancer : BluePrintEnhancer<AttributeDefinition>
+interface Blue
printAttributeDefinitionEnhancer : BlueprintEnhancer<AttributeDefinition>
-interface BluePrintEnhancerService {
+interface BlueprintEnhancerService {
- @Throws(BluePrintException::class)
- suspend fun enhance(basePath: String, enrichedBasePath: String): BluePrintContext
+ @Throws(BlueprintException::class)
+ suspend fun enhance(basePath: String, enrichedBasePath: String): BlueprintContext
- @Throws(BluePrintException::class)
- suspend fun enhance(basePath: String): BluePrintContext
+ @Throws(BlueprintException::class)
+ suspend fun enhance(basePath: String): BlueprintContext
}
-interface BluePrintTypeEnhancerService {
+interface BlueprintTypeEnhancerService {
- fun getServiceTemplateEnhancers(): List<BluePrintServiceTemplateEnhancer>
+ fun getServiceTemplateEnhancers(): List<BlueprintServiceTemplateEnhancer>
- fun getTopologyTemplateEnhancers(): List<BluePrintTopologyTemplateEnhancer>
+ fun getTopologyTemplateEnhancers(): List<BlueprintTopologyTemplateEnhancer>
- fun getWorkflowEnhancers(): List<BluePrintWorkflowEnhancer>
+ fun getWorkflowEnhancers(): List<BlueprintWorkflowEnhancer>
- fun getNodeTemplateEnhancers(): List<BluePrintNodeTemplateEnhancer>
+ fun getNodeTemplateEnhancers(): List<BlueprintNodeTemplateEnhancer>
- fun getNodeTypeEnhancers(): List<BluePrintNodeTypeEnhancer>
+ fun getNodeTypeEnhancers(): List<BlueprintNodeTypeEnhancer>
- fun getRelationshipTemplateEnhancers(): List<BluePrintRelationshipTemplateEnhancer>
+ fun getRelationshipTemplateEnhancers(): List<BlueprintRelationshipTemplateEnhancer>
- fun getRelationshipTypeEnhancers(): List<BluePrintRelationshipTypeEnhancer>
+ fun getRelationshipTypeEnhancers(): List<BlueprintRelationshipTypeEnhancer>
- fun getArtifactDefinitionEnhancers(): List<BluePrintArtifactDefinitionEnhancer>
+ fun getArtifactDefinitionEnhancers(): List<BlueprintArtifactDefinitionEnhancer>
- fun getPolicyTypeEnhancers(): List<BluePrintPolicyTypeEnhancer>
+ fun getPolicyTypeEnhancers(): List<BlueprintPolicyTypeEnhancer>
- fun getPropertyDefinitionEnhancers(): List<BluePrintPropertyDefinitionEnhancer>
+ fun getPropertyDefinitionEnhancers(): List<BlueprintPropertyDefinitionEnhancer>
- fun getAttributeDefinitionEnhancers(): List<BluePrintAttributeDefinitionEnhancer>
+ fun getAttributeDefinitionEnhancers(): List<BlueprintAttributeDefinitionEnhancer>
fun enhanceServiceTemplate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
serviceTemplate: ServiceTemplate
) {
}
fun enhanceTopologyTemplate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
topologyTemplate: TopologyTemplate
) {
doEnhancement(bluePrintRuntimeService, name, topologyTemplate, enhancers)
}
- fun enhanceWorkflow(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, workflow: Workflow) {
+ fun enhanceWorkflow(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, workflow: Workflow) {
val enhancers = getWorkflowEnhancers()
doEnhancement(bluePrintRuntimeService, name, workflow, enhancers)
}
fun enhanceNodeTemplate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
nodeTemplate: NodeTemplate
) {
doEnhancement(bluePrintRuntimeService, name, nodeTemplate, enhancers)
}
- fun enhanceNodeType(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeType: NodeType) {
+ fun enhanceNodeType(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, nodeType: NodeType) {
val enhancers = getNodeTypeEnhancers()
doEnhancement(bluePrintRuntimeService, name, nodeType, enhancers)
}
fun enhanceRelationshipTemplate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
relationshipTemplate: RelationshipTemplate
) {
}
fun enhanceRelationshipType(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
relationshipType: RelationshipType
) {
}
fun enhanceArtifactDefinition(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
artifactDefinition: ArtifactDefinition
) {
doEnhancement(bluePrintRuntimeService, name, artifactDefinition, enhancers)
}
- fun enhancePolicyType(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, policyType: PolicyType) {
+ fun enhancePolicyType(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, policyType: PolicyType) {
val enhancers = getPolicyTypeEnhancers()
doEnhancement(bluePrintRuntimeService, name, policyType, enhancers)
}
fun enhancePropertyDefinitions(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
properties: MutableMap<String, PropertyDefinition>
) {
- val errorMap = linkedMapOf<String, BluePrintException>()
+ val errorMap = linkedMapOf<String, BlueprintException>()
properties.forEach { propertyName, propertyDefinition ->
try {
enhancePropertyDefinition(bluePrintRuntimeService, propertyName, propertyDefinition)
- } catch (e: BluePrintException) {
+ } catch (e: BlueprintException) {
errorMap[propertyName] = e
}
}
if (errorMap.isNotEmpty()) {
val nestedErrors = errorMap.keys.map { "[ property: ${errorMap[it]?.message} ]" }.joinToString(";")
- throw BluePrintException("Failed to enhance properties $nestedErrors")
+ throw BlueprintException("Failed to enhance properties $nestedErrors")
}
}
fun enhancePropertyDefinition(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
propertyDefinition: PropertyDefinition
) {
}
fun enhanceAttributeDefinitions(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
attributes: MutableMap<String, AttributeDefinition>
) {
- val errorMap = linkedMapOf<String, BluePrintException>()
+ val errorMap = linkedMapOf<String, BlueprintException>()
attributes.forEach { attributeName, attributeDefinition ->
try {
enhanceAttributeDefinition(bluePrintRuntimeService, attributeName, attributeDefinition)
- } catch (e: BluePrintException) {
+ } catch (e: BlueprintException) {
errorMap[attributeName] = e
}
}
if (errorMap.isNotEmpty()) {
val nestedErrors = errorMap.keys.map { "[ attribute: ${errorMap[it]?.message} ]" }.joinToString(";")
- throw BluePrintException("Failed to enhance attributes $nestedErrors")
+ throw BlueprintException("Failed to enhance attributes $nestedErrors")
}
}
fun enhanceAttributeDefinition(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
attributeDefinition: AttributeDefinition
) {
@Suppress("UNCHECKED_CAST")
private fun <T> doEnhancement(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
definition: Any,
- enhancers: List<BluePrintEnhancer<T>>
+ enhancers: List<BlueprintEnhancer<T>>
) {
if (enhancers.isNotEmpty()) {
- val errorMap = linkedMapOf<String, BluePrintException>()
+ val errorMap = linkedMapOf<String, BlueprintException>()
enhancers.forEach {
try {
it.enhance(bluePrintRuntimeService, name, definition as T)
- } catch (e: BluePrintException) {
+ } catch (e: BlueprintException) {
errorMap[name] = e
}
}
val nestedErrors = errorMap.keys.map {
"${errorMap[it]?.message ?: errorMap[it].toString()}"
}.joinToString(";")
- throw BluePrintException("$name-->$nestedErrors")
+ throw BlueprintException("$name-->$nestedErrors")
}
}
}
package org.onap.ccsdk.cds.controllerblueprints.core.interfaces
import kotlinx.coroutines.runBlocking
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import java.util.function.Function
interface BlueprintFunctionNode<T, R> : Function<T, R> {
fun getName(): String
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun prepareRequest(executionRequest: T): T = runBlocking {
prepareRequestNB(executionRequest)
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun process(executionRequest: T) = runBlocking {
processNB(executionRequest)
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun recover(runtimeException: RuntimeException, executionRequest: T) = runBlocking {
recoverNB(runtimeException, executionRequest)
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun prepareResponse(): R = runBlocking {
prepareResponseNB()
}
return prepareResponse()
}
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
suspend fun prepareRequestNB(executionRequest: T): T
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
suspend fun processNB(executionRequest: T)
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: T)
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
suspend fun prepareResponseNB(): R
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
suspend fun applyNB(t: T): R
}
package org.onap.ccsdk.cds.controllerblueprints.core.interfaces
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import java.io.Serializable
/**
- * BluePrintRepoFileService
+ * BlueprintRepoFileService
* @author Brinda Santh
*
*/
-interface BluePrintRepoService : Serializable {
+interface BlueprintRepoService : Serializable {
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun getNodeType(nodeTypeName: String): NodeType
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun getDataType(dataTypeName: String): DataType
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun getArtifactType(artifactTypeName: String): ArtifactType
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun getRelationshipType(relationshipTypeName: String): RelationshipType
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun getCapabilityDefinition(capabilityDefinitionName: String): CapabilityDefinition
}
package org.onap.ccsdk.cds.controllerblueprints.core.interfaces
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintSourceCode
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintSourceCode
-interface BluePrintScriptsService {
+interface BlueprintScriptsService {
- suspend fun <T> scriptInstance(bluePrintSourceCode: BluePrintSourceCode, scriptClassName: String): T
+ suspend fun <T> scriptInstance(bluePrintSourceCode: BlueprintSourceCode, scriptClassName: String): T
suspend fun <T> scriptInstance(
blueprintBasePath: String,
import com.fasterxml.jackson.core.io.CharTypes
import com.fasterxml.jackson.databind.node.JsonNodeFactory
import com.fasterxml.jackson.databind.node.TextNode
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
interface BlueprintTemplateService {
*
**/
suspend fun generateContent(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
nodeTemplateName: String,
artifactName: String,
jsonData: String = "",
/**
* Customise JsonNodeFactory and TextNode, Since it introduces quotes for string data.
*/
-open class BluePrintJsonNodeFactory : JsonNodeFactory() {
+open class BlueprintJsonNodeFactory : JsonNodeFactory() {
override fun textNode(text: String): TextNode {
- return BluePrintTextNode(text)
+ return BlueprintTextNode(text)
}
}
-open class BluePrintTextNode(v: String) : TextNode(v) {
+open class BlueprintTextNode(v: String) : TextNode(v) {
override fun toString(): String {
var len = this._value.length
package org.onap.ccsdk.cds.controllerblueprints.core.interfaces
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
-interface BluePrintValidator<T> {
+interface BlueprintValidator<T> {
- fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: T)
+ fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, type: T)
}
-interface BluePrintServiceTemplateValidator : BluePrintValidator<ServiceTemplate>
+interface BlueprintServiceTemplateValidator : BlueprintValidator<ServiceTemplate>
-interface BluePrintTopologyTemplateValidator : BluePrintValidator<TopologyTemplate>
+interface BlueprintTopologyTemplateValidator : BlueprintValidator<TopologyTemplate>
-interface Blue
PrintArtifactTypeValidator : BluePrintValidator<ArtifactType>
+interface Blue
printArtifactTypeValidator : BlueprintValidator<ArtifactType>
-interface Blue
PrintArtifactDefinitionValidator : BluePrintValidator<ArtifactDefinition>
+interface Blue
printArtifactDefinitionValidator : BlueprintValidator<ArtifactDefinition>
-interface BluePrintDataTypeValidator : BluePrintValidator<DataType>
+interface BlueprintDataTypeValidator : BlueprintValidator<DataType>
-interface BluePrintNodeTypeValidator : BluePrintValidator<NodeType>
+interface BlueprintNodeTypeValidator : BlueprintValidator<NodeType>
-interface BluePrintNodeTemplateValidator : BluePrintValidator<NodeTemplate>
+interface BlueprintNodeTemplateValidator : BlueprintValidator<NodeTemplate>
-interface BluePrintWorkflowValidator : BluePrintValidator<Workflow>
+interface BlueprintWorkflowValidator : BlueprintValidator<Workflow>
-interface Blue
PrintPropertyDefinitionValidator : BluePrintValidator<PropertyDefinition>
+interface Blue
printPropertyDefinitionValidator : BlueprintValidator<PropertyDefinition>
-interface Blue
PrintAttributeDefinitionValidator : BluePrintValidator<AttributeDefinition>
+interface Blue
printAttributeDefinitionValidator : BlueprintValidator<AttributeDefinition>
/**
* Blueprint Validation Interface.
*/
-interface BluePrintValidatorService {
+interface BlueprintValidatorService {
- @Throws(BluePrintException::class)
- suspend fun validateBluePrints(basePath: String): Boolean
+ @Throws(BlueprintException::class)
+ suspend fun validateBlueprints(basePath: String): Boolean
- @Throws(BluePrintException::class)
- suspend fun validateBluePrints(bluePrintRuntimeService: BluePrintRuntimeService<*>): Boolean
+ @Throws(BlueprintException::class)
+ suspend fun validateBlueprints(bluePrintRuntimeService: BlueprintRuntimeService<*>): Boolean
}
-interface BluePrintTypeValidatorService {
+interface BlueprintTypeValidatorService {
- fun <T : BluePrintValidator<*>> bluePrintValidator(referenceName: String, classType: Class<T>): T?
+ fun <T : BlueprintValidator<*>> bluePrintValidator(referenceName: String, classType: Class<T>): T?
- fun <T : BluePrintValidator<*>> bluePrintValidators(referenceNamePrefix: String, classType: Class<T>): List<T>?
+ fun <T : BlueprintValidator<*>> bluePrintValidators(referenceNamePrefix: String, classType: Class<T>): List<T>?
- fun <T : BluePrintValidator<*>> bluePrintValidators(classType: Class<T>): List<T>?
+ fun <T : BlueprintValidator<*>> bluePrintValidators(classType: Class<T>): List<T>?
- fun getServiceTemplateValidators(): List<BluePrintServiceTemplateValidator>
+ fun getServiceTemplateValidators(): List<BlueprintServiceTemplateValidator>
- fun getDataTypeValidators(): List<BluePrintDataTypeValidator>
+ fun getDataTypeValidators(): List<BlueprintDataTypeValidator>
- fun getArtifactTypeValidators(): List<BluePrintArtifactTypeValidator>
+ fun getArtifactTypeValidators(): List<BlueprintArtifactTypeValidator>
- fun getArtifactDefinitionsValidators(): List<BluePrintArtifactDefinitionValidator>
+ fun getArtifactDefinitionsValidators(): List<BlueprintArtifactDefinitionValidator>
- fun getNodeTypeValidators(): List<BluePrintNodeTypeValidator>
+ fun getNodeTypeValidators(): List<BlueprintNodeTypeValidator>
- fun getTopologyTemplateValidators(): List<BluePrintTopologyTemplateValidator>
+ fun getTopologyTemplateValidators(): List<BlueprintTopologyTemplateValidator>
- fun getNodeTemplateValidators(): List<BluePrintNodeTemplateValidator>
+ fun getNodeTemplateValidators(): List<BlueprintNodeTemplateValidator>
- fun getWorkflowValidators(): List<BluePrintWorkflowValidator>
+ fun getWorkflowValidators(): List<BlueprintWorkflowValidator>
- fun getPropertyDefinitionValidators(): List<BluePrintPropertyDefinitionValidator>
+ fun getPropertyDefinitionValidators(): List<BlueprintPropertyDefinitionValidator>
- fun getAttributeDefinitionValidators(): List<BluePrintAttributeDefinitionValidator>
+ fun getAttributeDefinitionValidators(): List<BlueprintAttributeDefinitionValidator>
- fun validateServiceTemplate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, serviceTemplate: ServiceTemplate) {
+ fun validateServiceTemplate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, serviceTemplate: ServiceTemplate) {
val validators = getServiceTemplateValidators()
doValidation(bluePrintRuntimeService, name, serviceTemplate, validators)
}
- fun validateArtifactType(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, artifactType: ArtifactType) {
+ fun validateArtifactType(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, artifactType: ArtifactType) {
val validators = getArtifactTypeValidators()
doValidation(bluePrintRuntimeService, name, artifactType, validators)
}
fun validateArtifactDefinition(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
artifactDefinition: ArtifactDefinition
) {
doValidation(bluePrintRuntimeService, name, artifactDefinition, validators)
}
- fun validateDataType(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, dataType: DataType) {
+ fun validateDataType(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, dataType: DataType) {
val validators = getDataTypeValidators()
doValidation(bluePrintRuntimeService, name, dataType, validators)
}
- fun validateNodeType(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeType: NodeType) {
+ fun validateNodeType(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, nodeType: NodeType) {
val validators = getNodeTypeValidators()
doValidation(bluePrintRuntimeService, name, nodeType, validators)
}
- fun validateTopologyTemplate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, topologyTemplate: TopologyTemplate) {
+ fun validateTopologyTemplate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, topologyTemplate: TopologyTemplate) {
val validators = getTopologyTemplateValidators()
doValidation(bluePrintRuntimeService, name, topologyTemplate, validators)
}
- fun validateNodeTemplate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
+ fun validateNodeTemplate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
val validators = getNodeTemplateValidators()
doValidation(bluePrintRuntimeService, name, nodeTemplate, validators)
}
- fun validateWorkflow(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, workflow: Workflow) {
+ fun validateWorkflow(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, workflow: Workflow) {
val validators = getWorkflowValidators()
doValidation(bluePrintRuntimeService, name, workflow, validators)
}
- fun validatePropertyDefinitions(bluePrintRuntimeService: BluePrintRuntimeService<*>, properties: MutableMap<String, PropertyDefinition>) {
+ fun validatePropertyDefinitions(bluePrintRuntimeService: BlueprintRuntimeService<*>, properties: MutableMap<String, PropertyDefinition>) {
properties.forEach { propertyName, propertyDefinition ->
validatePropertyDefinition(bluePrintRuntimeService, propertyName, propertyDefinition)
}
}
- fun validatePropertyDefinition(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, propertyDefinition: PropertyDefinition) {
+ fun validatePropertyDefinition(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, propertyDefinition: PropertyDefinition) {
val validators = getPropertyDefinitionValidators()
doValidation(bluePrintRuntimeService, name, propertyDefinition, validators)
}
- fun validateAttributeDefinitions(bluePrintRuntimeService: BluePrintRuntimeService<*>, attributes: MutableMap<String, AttributeDefinition>) {
+ fun validateAttributeDefinitions(bluePrintRuntimeService: BlueprintRuntimeService<*>, attributes: MutableMap<String, AttributeDefinition>) {
attributes.forEach { attributeName, attributeDefinition ->
validateAttributeDefinition(bluePrintRuntimeService, attributeName, attributeDefinition)
}
}
- fun validateAttributeDefinition(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, attributeDefinition: AttributeDefinition) {
+ fun validateAttributeDefinition(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, attributeDefinition: AttributeDefinition) {
val validators = getAttributeDefinitionValidators()
doValidation(bluePrintRuntimeService, name, attributeDefinition, validators)
}
@Suppress("UNCHECKED_CAST")
private fun <T> doValidation(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
definition: Any,
- validators: List<BluePrintValidator<T>>
+ validators: List<BlueprintValidator<T>>
) {
validators.forEach {
it.validate(bluePrintRuntimeService, name, definition as T)
package org.onap.ccsdk.cds.controllerblueprints.core.interfaces
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
-interface BluePrintWorkflowExecutionService<Input, Output> {
+interface BlueprintWorkflowExecutionService<Input, Output> {
- suspend fun executeBluePrintWorkflow(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ suspend fun executeBlueprintWorkflow(
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
executionServiceInput: Input,
properties: MutableMap<String, Any> = hashMapOf()
): Output
import org.jetbrains.kotlin.cli.common.messages.MessageCollector
import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
import org.jetbrains.kotlin.config.Services
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.checkFileExists
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import java.io.File
import kotlin.script.experimental.jvm.util.classpathFromClasspathProperty
import kotlin.system.measureTimeMillis
-open class BluePrintCompileService {
+open class BlueprintCompileService {
- val log = logger(BluePrintCompileService::class)
+ val log = logger(BlueprintCompileService::class)
companion object {
/** Compile the [bluePrintSourceCode] and get the [kClassName] instance for the constructor [args] */
suspend fun <T> eval(
- bluePrintSourceCode: BluePrintSourceCode,
+ bluePrintSourceCode: BlueprintSourceCode,
kClassName: String,
args: ArrayList<Any?>?
): T {
}
}
- val classLoaderWithDependencies = BluePrintCompileCache.classLoader(bluePrintSourceCode.cacheKey)
+ val classLoaderWithDependencies = BlueprintCompileCache.classLoader(bluePrintSourceCode.cacheKey)
/** Create the instance from the class loader */
return instance(classLoaderWithDependencies, kClassName, args)
}
/** Compile [bluePrintSourceCode] and put into cache */
- suspend fun compile(bluePrintSourceCode: BluePrintSourceCode) {
+ suspend fun compile(bluePrintSourceCode: BlueprintSourceCode) {
// TODO("Include Multiple folders")
val sourcePath = bluePrintSourceCode.blueprintKotlinSources.first()
val compiledJarFile = bluePrintSourceCode.targetJarFile
checkFileExists(compiledJarFile) { "couldn't generate compiled jar(${compiledJarFile.absolutePath})" }
}
else -> {
- throw BluePrintException("$exitCode :${messageCollector.errors().joinToString("\n")}")
+ throw BlueprintException("$exitCode :${messageCollector.errors().joinToString("\n")}")
}
}
}
/** create class [kClassName] instance from [classLoader] */
fun <T> instance(classLoader: URLClassLoader, kClassName: String, args: ArrayList<Any?>? = arrayListOf()): T {
val kClazz = classLoader.loadClass(kClassName)
- ?: throw BluePrintException("failed to load class($kClassName) from current class loader.")
+ ?: throw BlueprintException("failed to load class($kClassName) from current class loader.")
val instance = if (args.isNullOrEmpty()) {
kClazz.newInstance()
} else {
kClazz.constructors
.single().newInstance(*args.toArray())
- } ?: throw BluePrintException("failed to create class($kClassName) instance for constructor argument($args).")
+ } ?: throw BlueprintException("failed to create class($kClassName) instance for constructor argument($args).")
return instance as T
}
}
/** Compile source code information */
-open class BluePrintSourceCode : SourceCode {
+open class BlueprintSourceCode : SourceCode {
lateinit var blueprintKotlinSources: MutableList<String>
lateinit var moduleName: String
import com.google.common.cache.CacheBuilder
import com.google.common.cache.CacheLoader
import com.google.common.cache.LoadingCache
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintFileUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintFileUtils
import java.net.URLClassLoader
-object BluePrintCompileCache {
+object BlueprintCompileCache {
- val log = logger(BluePrintCompileCache::class)
+ val log = logger(BlueprintCompileCache::class)
private val classLoaderCache: LoadingCache<String, URLClassLoader> = CacheBuilder.newBuilder()
.maximumSize(50)
- .build(BluePrintClassLoader)
+ .build(BlueprintClassLoader)
fun classLoader(key: String): URLClassLoader {
return classLoaderCache.get(key)
}
}
-object BluePrintClassLoader : CacheLoader<String, URLClassLoader>() {
+object BlueprintClassLoader : CacheLoader<String, URLClassLoader>() {
- val log = logger(BluePrintClassLoader::class)
+ val log = logger(BlueprintClassLoader::class)
override fun load(key: String) = try {
log.info("loading compiled cache($key)")
- BluePrintFileUtils.getURLClassLoaderFromDirectory(key)
+ BlueprintFileUtils.getURLClassLoaderFromDirectory(key)
} catch (e: Exception) {
- throw BluePrintException("failed to load cache($key) with Exception($e)")
+ throw BlueprintException("failed to load cache($key) with Exception($e)")
}
}
package org.onap.ccsdk.cds.controllerblueprints.core.scripts
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintScriptsService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintScriptsService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintFileUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintFileUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import java.util.ArrayList
-open class BluePrintScriptsServiceImpl : BluePrintScriptsService {
+open class BlueprintScriptsServiceImpl : BlueprintScriptsService {
- val log = logger(BluePrintScriptsServiceImpl::class)
+ val log = logger(BlueprintScriptsServiceImpl::class)
- override suspend fun <T> scriptInstance(bluePrintSourceCode: BluePrintSourceCode, scriptClassName: String): T {
- val bluePrintCompileService = BluePrintCompileService()
+ override suspend fun <T> scriptInstance(bluePrintSourceCode: BlueprintSourceCode, scriptClassName: String): T {
+ val bluePrintCompileService = BlueprintCompileService()
return bluePrintCompileService.eval(bluePrintSourceCode, scriptClassName, null)
}
): T {
val sources: MutableList<String> = arrayListOf()
- sources.add(normalizedPathName(blueprintBasePath, BluePrintConstants.TOSCA_SCRIPTS_KOTLIN_DIR))
+ sources.add(normalizedPathName(blueprintBasePath, BlueprintConstants.TOSCA_SCRIPTS_KOTLIN_DIR))
- val scriptSource = BluePrintSourceCode()
+ val scriptSource = BlueprintSourceCode()
scriptSource.blueprintKotlinSources = sources
scriptSource.moduleName = "$artifactName-$artifactVersion-cba-kts"
- scriptSource.cacheKey = BluePrintFileUtils.compileCacheKey(blueprintBasePath)
- scriptSource.targetJarFile = BluePrintFileUtils.compileJarFile(blueprintBasePath, artifactName, artifactVersion)
+ scriptSource.cacheKey = BlueprintFileUtils.compileCacheKey(blueprintBasePath)
+ scriptSource.targetJarFile = BlueprintFileUtils.compileJarFile(blueprintBasePath, artifactName, artifactVersion)
scriptSource.regenerate = reCompile
return scriptInstance(scriptSource, scriptClassName)
}
scriptClassName: String,
reCompile: Boolean
): T {
- val toscaMetaData = BluePrintMetadataUtils.toscaMetaData(blueprintBasePath)
+ val toscaMetaData = BlueprintMetadataUtils.toscaMetaData(blueprintBasePath)
checkNotNull(toscaMetaData.templateName) { "couldn't find 'Template-Name' key in TOSCA.meta" }
checkNotNull(toscaMetaData.templateVersion) { "couldn't find 'Template-Version' key in TOSCA.meta" }
return scriptInstance(
override suspend fun <T> scriptInstance(cacheKey: String, scriptClassName: String): T {
val args = ArrayList<Any?>()
- return BluePrintCompileCache.classLoader(cacheKey).loadClass(scriptClassName).constructors
+ return BlueprintCompileCache.classLoader(cacheKey).loadClass(scriptClassName).constructors
.single().newInstance(*args.toArray()) as T
}
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
*
* @author Brinda Santh
*/
-internal class BluePrintChainedService {
+internal class BlueprintChainedService {
- var bpc: BluePrintContext
+ var bpc: BlueprintContext
- constructor(bpc: BluePrintContext) {
+ constructor(bpc: BlueprintContext) {
this.bpc = bpc
}
val nodeType: NodeType = bpc.nodeTypeByName(nodeTypeName)
nodeType.id = nodeTypeName
val derivedFrom: String = nodeType.derivedFrom
- if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {
+ if (!BlueprintTypes.rootNodeTypes().contains(derivedFrom)) {
recNodeTypesChained(derivedFrom, nodeTypes)
}
nodeTypes!!.add(nodeType)
val dataType: DataType = bpc.dataTypeByName(dataTypeName)!!
dataType.id = dataTypeName
val derivedFrom: String = dataType.derivedFrom
- if (!BluePrintTypes.rootDataTypes().contains(derivedFrom)) {
+ if (!BlueprintTypes.rootDataTypes().contains(derivedFrom)) {
recDataTypesChained(derivedFrom, dataTypes)
}
dataTypes!!.add(dataType)
package org.onap.ccsdk.cds.controllerblueprints.core.service
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityAssignment
*
* @author Brinda Santh
*/
-class BluePrintContext(val serviceTemplate: ServiceTemplate) {
+class BlueprintContext(val serviceTemplate: ServiceTemplate) {
private val log = LoggerFactory.getLogger(this::class.toString())
return JacksonUtils.getJson(serviceTemplate, pretty)
}
- fun name(): String = metadata?.get(BluePrintConstants.METADATA_TEMPLATE_NAME)
- ?: throw BluePrintException("could't get template name from meta data")
+ fun name(): String = metadata?.get(BlueprintConstants.METADATA_TEMPLATE_NAME)
+ ?: throw BlueprintException("could't get template name from meta data")
- fun version(): String = metadata?.get(BluePrintConstants.METADATA_TEMPLATE_VERSION)
- ?: throw BluePrintException("could't get template version from meta data")
+ fun version(): String = metadata?.get(BlueprintConstants.METADATA_TEMPLATE_VERSION)
+ ?: throw BlueprintException("could't get template version from meta data")
- fun author(): String = metadata?.get(BluePrintConstants.METADATA_TEMPLATE_AUTHOR)
- ?: throw BluePrintException("could't get template author from meta data")
+ fun author(): String = metadata?.get(BlueprintConstants.METADATA_TEMPLATE_AUTHOR)
+ ?: throw BlueprintException("could't get template author from meta data")
// Workflow
fun workflows(): MutableMap<String, Workflow>? = serviceTemplate.topologyTemplate?.workflows
fun workflowByName(workFlowName: String): Workflow = workflows()?.get(workFlowName)
- ?: throw BluePrintException("could't get workflow($workFlowName)")
+ ?: throw BlueprintException("could't get workflow($workFlowName)")
fun workflowInputs(workFlowName: String) = workflowByName(workFlowName).inputs
fun workflowStepByName(workFlowName: String, stepName: String): Step {
return workflowByName(workFlowName).steps?.get(stepName)
- ?: throw BluePrintException("could't get step($stepName) for workflow($workFlowName)")
+ ?: throw BlueprintException("could't get step($stepName) for workflow($workFlowName)")
}
fun workflowStepNodeTemplate(workFlowName: String, stepName: String): String {
return workflowStepByName(workFlowName, stepName).target
- ?: throw BluePrintException("could't get node template name for workflow($workFlowName)'s step($stepName)")
+ ?: throw BlueprintException("could't get node template name for workflow($workFlowName)'s step($stepName)")
}
fun workflowFirstStepNodeTemplate(workFlowName: String): String {
val firstStepName = workflowByName(workFlowName).steps?.keys?.first()
- ?: throw BluePrintException("could't get first step for workflow($workFlowName)")
+ ?: throw BlueprintException("could't get first step for workflow($workFlowName)")
return workflowStepNodeTemplate(workFlowName, firstStepName)
}
workFlowName,
stepName
).activities?.filter { it.callOperation != null }?.single()?.callOperation
- ?: throw BluePrintException("couldn't get first callOperation for WorkFlow($workFlowName) ")
+ ?: throw BlueprintException("couldn't get first callOperation for WorkFlow($workFlowName) ")
}
// DSL
fun dslPropertiesByName(name: String): JsonNode = dslDefinitions()?.get(name)
- ?: throw BluePrintException("couldn't get policy type for the dsl($name)")
+ ?: throw BlueprintException("couldn't get policy type for the dsl($name)")
// Data Type
fun dataTypeByName(name: String): DataType? = dataTypes()?.get(name)
fun policyTypes(): MutableMap<String, PolicyType>? = serviceTemplate.policyTypes
fun policyTypeByName(policyName: String) = policyTypes()?.get(policyName)
- ?: throw BluePrintException("could't get policy type for the name($policyName)")
+ ?: throw BlueprintException("could't get policy type for the name($policyName)")
fun policyTypesDerivedFrom(name: String): MutableMap<String, PolicyType>? {
return policyTypes()?.filterValues { policyType -> policyType.derivedFrom == name }?.toMutableMap()
fun nodeTypeByName(name: String): NodeType =
nodeTypes()?.get(name)
- ?: throw BluePrintException("could't get node type for the name($name)")
+ ?: throw BlueprintException("could't get node type for the name($name)")
fun nodeTypeDerivedFrom(name: String): MutableMap<String, NodeType>? {
return nodeTypes()?.filterValues { nodeType -> nodeType.derivedFrom == name }?.toMutableMap()
fun nodeTypeInterface(nodeTypeName: String, interfaceName: String): InterfaceDefinition {
return nodeTypeByName(nodeTypeName).interfaces?.get(interfaceName)
- ?: throw BluePrintException("could't get node type($nodeTypeName)'s interface definition($interfaceName)")
+ ?: throw BlueprintException("could't get node type($nodeTypeName)'s interface definition($interfaceName)")
}
fun nodeTypeInterfaceOperation(
operationName: String
): OperationDefinition {
return nodeTypeInterface(nodeTypeName, interfaceName).operations?.get(operationName)
- ?: throw BluePrintException("could't get node type($nodeTypeName)'s interface definition($interfaceName) operation definition($operationName)")
+ ?: throw BlueprintException("could't get node type($nodeTypeName)'s interface definition($interfaceName) operation definition($operationName)")
}
fun interfaceNameForNodeType(nodeTypeName: String): String {
return nodeTypeByName(nodeTypeName).interfaces?.keys?.first()
- ?: throw BluePrintException("could't get NodeType($nodeTypeName)'s first InterfaceDefinition name")
+ ?: throw BlueprintException("could't get NodeType($nodeTypeName)'s first InterfaceDefinition name")
}
fun nodeTypeInterfaceOperationInputs(
fun relationshipTypes(): MutableMap<String, RelationshipType>? = serviceTemplate.relationshipTypes
fun relationshipTypeByName(name: String): RelationshipType = relationshipTypes()?.get(name)
- ?: throw BluePrintException("could't get relationship type for the name($name)")
+ ?: throw BlueprintException("could't get relationship type for the name($name)")
// Node Template Methods
fun nodeTemplates(): MutableMap<String, NodeTemplate>? = serviceTemplate.topologyTemplate?.nodeTemplates
fun nodeTemplateByName(name: String): NodeTemplate =
- nodeTemplates()?.get(name) ?: throw BluePrintException("could't get node template for the name($name)")
+ nodeTemplates()?.get(name) ?: throw BlueprintException("could't get node template for the name($name)")
fun nodeTemplateForNodeType(name: String): MutableMap<String, NodeTemplate>? {
return nodeTemplates()?.filterValues { nodeTemplate -> nodeTemplate.type == name }?.toMutableMap()
fun nodeTemplateArtifact(nodeTemplateName: String, artifactName: String): ArtifactDefinition {
return checkNodeTemplateArtifact(nodeTemplateName, artifactName)
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s ArtifactDefinition($artifactName)")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s ArtifactDefinition($artifactName)")
}
fun nodeTemplateArtifactForArtifactType(nodeTemplateName: String, artifactType: String): ArtifactDefinition {
return nodeTemplateArtifacts(nodeTemplateName)?.filter { it.value.type == artifactType }?.map { it.value }?.get(0)
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s Artifact Type($artifactType)")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s Artifact Type($artifactType)")
}
fun nodeTemplateFirstInterface(nodeTemplateName: String): InterfaceAssignment {
return nodeTemplateByName(nodeTemplateName).interfaces?.values?.first()
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment")
}
fun nodeTemplateFirstInterfaceName(nodeTemplateName: String): String {
return nodeTemplateByName(nodeTemplateName).interfaces?.keys?.first()
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment name")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment name")
}
fun nodeTemplateFirstInterfaceFirstOperationName(nodeTemplateName: String): String {
return nodeTemplateFirstInterface(nodeTemplateName).operations?.keys?.first()
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment's first OperationAssignment name")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s first InterfaceAssignment's first OperationAssignment name")
}
fun nodeTemplateOperationImplementation(nodeTemplateName: String, interfaceName: String, operationName: String):
fun nodeTemplateInterface(nodeTemplateName: String, interfaceName: String): InterfaceAssignment {
return nodeTemplateByName(nodeTemplateName).interfaces?.get(interfaceName)
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName)")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName)")
}
fun nodeTemplateInterfaceOperation(
operationName: String
): OperationAssignment {
return nodeTemplateInterface(nodeTemplateName, interfaceName).operations?.get(operationName)
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName) OperationAssignment($operationName)")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s InterfaceAssignment($interfaceName) OperationAssignment($operationName)")
}
fun nodeTemplateCapability(nodeTemplateName: String, capabilityName: String): CapabilityAssignment {
return nodeTemplateByName(nodeTemplateName).capabilities?.get(capabilityName)
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s CapabilityAssignment($capabilityName)")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s CapabilityAssignment($capabilityName)")
}
fun nodeTemplateRequirement(nodeTemplateName: String, requirementName: String): RequirementAssignment {
return nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)
- ?: throw BluePrintException("could't get NodeTemplate($nodeTemplateName)'s first RequirementAssignment($requirementName)")
+ ?: throw BlueprintException("could't get NodeTemplate($nodeTemplateName)'s first RequirementAssignment($requirementName)")
}
fun nodeTemplateRequirementNode(nodeTemplateName: String, requirementName: String): NodeTemplate {
val filteredNodeTemplateName: String =
nodeTemplateByName(nodeTemplateName).requirements?.get(requirementName)?.node
- ?: throw BluePrintException("could't NodeTemplate for NodeTemplate's($nodeTemplateName) requirement's ($requirementName) ")
+ ?: throw BlueprintException("could't NodeTemplate for NodeTemplate's($nodeTemplateName) requirement's ($requirementName) ")
return nodeTemplateByName(filteredNodeTemplateName)
}
serviceTemplate.topologyTemplate?.relationshipTemplates
fun relationshipTemplateByName(name: String): RelationshipTemplate = relationshipTemplates()?.get(name)
- ?: throw BluePrintException("could't get relationship template for the name($name)")
+ ?: throw BlueprintException("could't get relationship template for the name($name)")
fun relationshipTemplateProperty(relationshipTemplateName: String, propertyName: String): Any? {
return nodeTemplateByName(relationshipTemplateName).properties?.get(propertyName)
// Chained Functions
fun nodeTypeChained(nodeTypeName: String): NodeType {
- return BluePrintChainedService(this).nodeTypeChained(nodeTypeName)
+ return BlueprintChainedService(this).nodeTypeChained(nodeTypeName)
}
fun nodeTypeChainedProperties(nodeTypeName: String): MutableMap<String, PropertyDefinition>? {
- return BluePrintChainedService(this).nodeTypeChainedProperties(nodeTypeName)
+ return BlueprintChainedService(this).nodeTypeChainedProperties(nodeTypeName)
}
}
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.springframework.context.ApplicationContext
import org.springframework.context.ConfigurableApplicationContext
import kotlin.reflect.KClass
* @author Brinda Santh
*/
-object BluePrintDependencyService {
+object BlueprintDependencyService {
lateinit var applicationContext: ApplicationContext
fun inject(applicationContext: ApplicationContext) {
- BluePrintDependencyService.applicationContext = applicationContext
+ BlueprintDependencyService.applicationContext = applicationContext
}
/** Used to inject [instance] into spring application context for the [key],
inline fun <reified T> instance(name: String): T {
return applicationContext.getBean(name) as? T
- ?: throw BluePrintProcessorException("failed to get instance($name)")
+ ?: throw BlueprintProcessorException("failed to get instance($name)")
}
inline fun <reified T> instance(type: Class<T>): T {
return applicationContext.getBean(type)
- ?: throw BluePrintProcessorException("failed to get instance($type)")
+ ?: throw BlueprintProcessorException("failed to get instance($type)")
}
inline fun <reified T> instance(type: KClass<*>): T {
return applicationContext.getBean(type.java) as? T
- ?: throw BluePrintProcessorException("failed to get instance($type)")
+ ?: throw BlueprintProcessorException("failed to get instance($type)")
}
}
import com.fasterxml.jackson.databind.node.ArrayNode
import com.fasterxml.jackson.databind.node.ObjectNode
import com.fasterxml.jackson.databind.node.TextNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactExpression
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeExpression
import org.onap.ccsdk.cds.controllerblueprints.core.data.DSLExpression
*
* @author Brinda Santh
*/
-object BluePrintExpressionService {
+object BlueprintExpressionService {
val log = LoggerFactory.getLogger(this::class.toString())
val json = propertyAssignmentNode.toString()
// FIXME("Check if any Optimisation needed")
return (
- json.contains(BluePrintConstants.EXPRESSION_GET_INPUT) ||
- json.contains(BluePrintConstants.EXPRESSION_GET_ATTRIBUTE) ||
- json.contains(BluePrintConstants.EXPRESSION_GET_PROPERTY)
+ json.contains(BlueprintConstants.EXPRESSION_GET_INPUT) ||
+ json.contains(BlueprintConstants.EXPRESSION_GET_ATTRIBUTE) ||
+ json.contains(BlueprintConstants.EXPRESSION_GET_PROPERTY)
)
}
log.trace("Assignment Data/Expression : {}", propertyAssignmentNode)
val expressionData = ExpressionData(valueNode = propertyAssignmentNode)
if (propertyAssignmentNode is ObjectNode) {
- val commands: Set<String> = propertyAssignmentNode.fieldNames().asSequence().toList().intersect(BluePrintTypes.validCommands())
+ val commands: Set<String> = propertyAssignmentNode.fieldNames().asSequence().toList().intersect(BlueprintTypes.validCommands())
if (commands.isNotEmpty()) {
expressionData.isExpression = true
expressionData.command = commands.first()
expressionData.expressionNode = propertyAssignmentNode
when (expressionData.command) {
- BluePrintConstants.EXPRESSION_GET_INPUT -> {
+ BlueprintConstants.EXPRESSION_GET_INPUT -> {
expressionData.inputExpression = populateInputExpression(propertyAssignmentNode)
}
- BluePrintConstants.EXPRESSION_GET_ATTRIBUTE -> {
+ BlueprintConstants.EXPRESSION_GET_ATTRIBUTE -> {
expressionData.attributeExpression = populateAttributeExpression(propertyAssignmentNode)
}
- BluePrintConstants.EXPRESSION_GET_PROPERTY -> {
+ BlueprintConstants.EXPRESSION_GET_PROPERTY -> {
expressionData.propertyExpression = populatePropertyExpression(propertyAssignmentNode)
}
- BluePrintConstants.EXPRESSION_GET_OPERATION_OUTPUT -> {
+ BlueprintConstants.EXPRESSION_GET_OPERATION_OUTPUT -> {
expressionData.operationOutputExpression = populateOperationOutputExpression(propertyAssignmentNode)
}
- BluePrintConstants.EXPRESSION_GET_ARTIFACT -> {
+ BlueprintConstants.EXPRESSION_GET_ARTIFACT -> {
expressionData.artifactExpression = populateArtifactExpression(propertyAssignmentNode)
}
}
}
} else if (propertyAssignmentNode is TextNode &&
- propertyAssignmentNode.textValue().startsWith(BluePrintConstants.EXPRESSION_DSL_REFERENCE)
+ propertyAssignmentNode.textValue().startsWith(BlueprintConstants.EXPRESSION_DSL_REFERENCE)
) {
expressionData.isExpression = true
- expressionData.command = BluePrintConstants.EXPRESSION_DSL_REFERENCE
+ expressionData.command = BlueprintConstants.EXPRESSION_DSL_REFERENCE
expressionData.dslExpression = populateDSLExpression(propertyAssignmentNode)
}
return expressionData
fun populateDSLExpression(jsonNode: TextNode): DSLExpression {
return DSLExpression(
propertyName = jsonNode.textValue()
- .removePrefix(BluePrintConstants.EXPRESSION_DSL_REFERENCE)
+ .removePrefix(BlueprintConstants.EXPRESSION_DSL_REFERENCE)
)
}
fun populatePropertyExpression(jsonNode: JsonNode): PropertyExpression {
val arrayNode: ArrayNode = jsonNode.first() as ArrayNode
check(arrayNode.size() >= 2) {
- throw BluePrintException(
+ throw BlueprintException(
String.format(
"missing property expression, " +
"it should be [ <modelable_entity_name>, <optional_req_or_cap_name>, <property_name>, " +
fun populateAttributeExpression(jsonNode: JsonNode): AttributeExpression {
val arrayNode: ArrayNode = jsonNode.first() as ArrayNode
check(arrayNode.size() >= 2) {
- throw BluePrintException(
+ throw BlueprintException(
String.format(
"missing attribute expression, " +
"it should be [ <modelable_entity_name>, <optional_req_or_cap_name>, <attribute_name>," +
val arrayNode: ArrayNode = jsonNode.first() as ArrayNode
check(arrayNode.size() >= 4) {
- throw BluePrintException(
+ throw BlueprintException(
String.format(
"missing operation output expression, " +
"it should be (<modelable_entity_name>, <interface_name>, <operation_name>, <output_variable_name>) , but present {}",
val arrayNode: ArrayNode = jsonNode.first() as ArrayNode
check(arrayNode.size() >= 2) {
- throw BluePrintException(
+ throw BlueprintException(
String.format(
"missing artifact expression, " +
"it should be [ <modelable_entity_name>, <artifact_name>, <location>, <remove> ] , but present {}",
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ImportDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ServiceTemplateUtils
import java.net.URLDecoder
import java.nio.charset.Charset
-class BluePrintImportService(private val parentServiceTemplate: ServiceTemplate, private val blueprintBasePath: String) {
+class BlueprintImportService(private val parentServiceTemplate: ServiceTemplate, private val blueprintBasePath: String) {
companion object {
private const val PARENT_SERVICE_TEMPLATE: String = "parent"
serviceTemplate = ServiceTemplateUtils.getServiceTemplate(importDefinition.file)
}
} catch (e: Exception) {
- throw BluePrintException("failed to populate service template for ${importDefinition.file} original error: ${e.message}", e)
+ throw BlueprintException("failed to populate service template for ${importDefinition.file} original error: ${e.message}", e)
}
if (serviceTemplate == null) {
- throw BluePrintException("failed to populate service template for : ${importDefinition.file}")
+ throw BlueprintException("failed to populate service template for : ${importDefinition.file}")
}
return serviceTemplate
}
import com.hubspot.jinjava.interpret.JinjavaInterpreter
import com.hubspot.jinjava.loader.ResourceLocator
import com.hubspot.jinjava.loader.ResourceNotFoundException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintJsonNodeFactory
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintJsonNodeFactory
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
import org.onap.ccsdk.cds.controllerblueprints.core.removeNullNode
import java.io.IOException
import java.nio.file.Files.readAllBytes
import java.nio.file.Paths
-object BluePrintJinjaTemplateService {
+object BlueprintJinjaTemplateService {
/**
* To enable inheritance within CBA, we need Jinja runtime to know where to load the templates.
*/
class BlueprintRelatedTemplateLocator(
- private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+ private val bluePrintLoadConfiguration: BlueprintLoadConfiguration,
private val artifactName: String,
private val artifactVersion: String
) : ResourceLocator {
json: String,
ignoreJsonNull: Boolean,
additionalContext: MutableMap<String, Any>,
- bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+ bluePrintLoadConfiguration: BlueprintLoadConfiguration,
artifactName: String,
artifactVersion: String
): String {
}
val mapper = ObjectMapper()
- val nodeFactory = BluePrintJsonNodeFactory()
+ val nodeFactory = BlueprintJsonNodeFactory()
mapper.nodeFactory = nodeFactory
// Add the JSON Data to the context
if (json.isNotEmpty()) {
val jsonNode = mapper.readValue<JsonNode>(json, JsonNode::class.java)
- ?: throw BluePrintProcessorException("couldn't get json node from json")
+ ?: throw BlueprintProcessorException("couldn't get json node from json")
if (ignoreJsonNull) {
jsonNode.removeNullNode()
}
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
-open class BluePrintRepoFileService(modelTypePath: String) : BluePrintRepoService {
+open class BlueprintRepoFileService(modelTypePath: String) : BlueprintRepoService {
- private val log = LoggerFactory.getLogger(BluePrintRepoFileService::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintRepoFileService::class.toString())
- private val dataTypePath = modelTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
- private val nodeTypePath = modelTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE)
- private val artifactTypePath = modelTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE)
+ private val dataTypePath = modelTypePath.plus(BlueprintConstants.PATH_DIVIDER).plus(BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
+ private val nodeTypePath = modelTypePath.plus(BlueprintConstants.PATH_DIVIDER).plus(BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE)
+ private val artifactTypePath = modelTypePath.plus(BlueprintConstants.PATH_DIVIDER).plus(BlueprintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE)
private val capabilityTypePath =
- modelTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE)
+ modelTypePath.plus(BlueprintConstants.PATH_DIVIDER).plus(BlueprintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE)
private val relationshipTypePath =
- modelTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE)
+ modelTypePath.plus(BlueprintConstants.PATH_DIVIDER).plus(BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE)
private val extension = ".json"
override fun getDataType(dataTypeName: String): DataType {
- val fileName = dataTypePath.plus(BluePrintConstants.PATH_DIVIDER)
+ val fileName = dataTypePath.plus(BlueprintConstants.PATH_DIVIDER)
.plus(dataTypeName).plus(extension)
return getModelType(fileName, DataType::class.java)
}
override fun getNodeType(nodeTypeName: String): NodeType {
- val fileName = nodeTypePath.plus(BluePrintConstants.PATH_DIVIDER).plus(nodeTypeName).plus(extension)
+ val fileName = nodeTypePath.plus(BlueprintConstants.PATH_DIVIDER).plus(nodeTypeName).plus(extension)
return getModelType(fileName, NodeType::class.java)
}
override fun getArtifactType(artifactTypeName: String): ArtifactType {
- val fileName = artifactTypePath.plus(BluePrintConstants.PATH_DIVIDER)
+ val fileName = artifactTypePath.plus(BlueprintConstants.PATH_DIVIDER)
.plus(artifactTypeName).plus(extension)
return getModelType(fileName, ArtifactType::class.java)
}
override fun getRelationshipType(relationshipTypeName: String): RelationshipType {
- val fileName = relationshipTypePath.plus(BluePrintConstants.PATH_DIVIDER)
+ val fileName = relationshipTypePath.plus(BlueprintConstants.PATH_DIVIDER)
.plus(relationshipTypeName).plus(extension)
return getModelType(fileName, RelationshipType::class.java)
}
override fun getCapabilityDefinition(capabilityDefinitionName: String): CapabilityDefinition {
- val fileName = capabilityTypePath.plus(BluePrintConstants.PATH_DIVIDER)
+ val fileName = capabilityTypePath.plus(BlueprintConstants.PATH_DIVIDER)
.plus(capabilityDefinitionName).plus(extension)
return getModelType(fileName, CapabilityDefinition::class.java)
}
private fun <T> getModelType(fileName: String, valueType: Class<T>): T {
return JacksonUtils.readValueFromFile(fileName, valueType)
- ?: throw BluePrintException("couldn't get file($fileName) for type(${valueType.name}")
+ ?: throw BlueprintException("couldn't get file($fileName) for type(${valueType.name}")
}
}
import com.fasterxml.jackson.databind.node.NullNode
import com.fasterxml.jackson.databind.node.ObjectNode
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.common.ApplicationConstants.LOG_REDACTED
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.returnNullIfMissing
import org.onap.ccsdk.cds.controllerblueprints.core.rootFieldsToMap
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.PropertyDefinitionUtils.Companion.hasLogProtect
import org.slf4j.LoggerFactory
import java.io.File
-interface BluePrintRuntimeService<T> {
+interface BlueprintRuntimeService<T> {
fun id(): String
- fun bluePrintContext(): BluePrintContext
+ fun bluePrintContext(): BlueprintContext
fun getExecutionContext(): T
fun getAsDouble(key: String): Double?
- fun getBluePrintError(): BluePrintError
+ fun getBlueprintError(): BlueprintError
- fun setBluePrintError(bluePrintError: BluePrintError)
+ fun setBlueprintError(bluePrintError: BlueprintError)
fun loadEnvironments(type: String, fileName: String)
*
* @author Brinda Santh
*/
-open class DefaultBluePrintRuntimeService(private var id: String, private var bluePrintContext: BluePrintContext) :
- BluePrintRuntimeService<MutableMap<String, JsonNode>> {
+open class DefaultBlueprintRuntimeService(private var id: String, private var bluePrintContext: BlueprintContext) :
+ BlueprintRuntimeService<MutableMap<String, JsonNode>> {
@Transient
- private val log = LoggerFactory.getLogger(BluePrintRuntimeService::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintRuntimeService::class.toString())
private var store: MutableMap<String, JsonNode> = hashMapOf()
- private var bluePrintError = BluePrintError()
+ private var bluePrintError = BlueprintError()
init {
/**
* Load Blueprint Environments Properties
*/
val absoluteEnvFilePath = bluePrintContext.rootPath.plus(File.separator)
- .plus(BluePrintConstants.TOSCA_ENVIRONMENTS_DIR)
- loadEnvironments(BluePrintConstants.PROPERTY_BPP, absoluteEnvFilePath)
+ .plus(BlueprintConstants.TOSCA_ENVIRONMENTS_DIR)
+ loadEnvironments(BlueprintConstants.PROPERTY_BPP, absoluteEnvFilePath)
}
override fun id(): String {
return id
}
- override fun bluePrintContext(): BluePrintContext {
+ override fun bluePrintContext(): BlueprintContext {
return bluePrintContext
}
}
override fun get(key: String): JsonNode {
- return store[key] ?: throw BluePrintProcessorException("failed to get execution property($key)")
+ return store[key] ?: throw BlueprintProcessorException("failed to get execution property($key)")
}
override fun check(key: String): Boolean {
return get(key).asDouble()
}
- override fun getBluePrintError(): BluePrintError {
+ override fun getBlueprintError(): BlueprintError {
return this.bluePrintError
}
- override fun setBluePrintError(bluePrintError: BluePrintError) {
+ override fun setBlueprintError(bluePrintError: BlueprintError) {
this.bluePrintError = bluePrintError
}
override fun loadEnvironments(type: String, fileName: String) {
- BluePrintMetadataUtils.environmentFileProperties(fileName).forEach { key, value ->
+ BlueprintMetadataUtils.environmentFileProperties(fileName).forEach { key, value ->
setNodeTemplateAttributeValue(type, key.toString(), value.asJsonType())
}
}
override fun resolveWorkflowOutputs(workflowName: String): MutableMap<String, JsonNode> {
log.info("resolveWorkflowOutputs for workflow($workflowName)")
val outputs = bluePrintContext.workflowByName(workflowName).outputs ?: mutableMapOf()
- return resolvePropertyDefinitions(BluePrintConstants.MODEL_DEFINITION_TYPE_WORKFLOW, "WORKFLOW", outputs)
+ return resolvePropertyDefinitions(BlueprintConstants.MODEL_DEFINITION_TYPE_WORKFLOW, "WORKFLOW", outputs)
}
/**
*/
override fun resolveDSLExpression(dslPropertyName: String): JsonNode {
val propertyAssignments = bluePrintContext.dslPropertiesByName(dslPropertyName)
- return if (BluePrintExpressionService.checkContainsExpression(propertyAssignments) &&
+ return if (BlueprintExpressionService.checkContainsExpression(propertyAssignments) &&
propertyAssignments is ObjectNode
) {
val rootKeyMap = propertyAssignments.rootFieldsToMap()
val propertyAssignmentExpression = PropertyAssignmentService(this)
propertyAssignmentValue[propertyName] = propertyAssignmentExpression
.resolveAssignmentExpression(
- BluePrintConstants.MODEL_DEFINITION_TYPE_DSL,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DSL,
"DSL",
propertyName,
propertyValue
}
/** If property is Map type, then resolve the property value, It may have expressions */
- if (nodeTypeProperty.type == BluePrintConstants.DATA_TYPE_MAP &&
+ if (nodeTypeProperty.type == BlueprintConstants.DATA_TYPE_MAP &&
resolvedValue.returnNullIfMissing() != null
) {
val mapResolvedValue = resolvePropertyAssignments(
propertyAssignments: MutableMap<String, JsonNode>
): MutableMap<String, JsonNode> {
return resolvePropertyAssignments(
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
nodeTemplateName, propertyDefinitions, propertyAssignments
)
}
val nodeTemplate = bluePrintContext.nodeTemplateByName(nodeTemplateName)
return nodeTemplate.artifacts?.get(artifactName)
- ?: throw BluePrintProcessorException(
+ ?: throw BlueprintProcessorException(
"failed to get artifact definition($artifactName) from the node template"
)
}
// Get the Relationship Type Definitions
val propertiesDefinitions = bluePrintContext.relationshipTypeByName(relationshipTemplate.type).properties
- ?: throw BluePrintProcessorException("failed to get ${relationshipTemplate.type} properties.")
+ ?: throw BlueprintProcessorException("failed to get ${relationshipTemplate.type} properties.")
/**
* Resolve the RelationshipTemplate Property Assignment Values.
propertyAssignments: MutableMap<String, JsonNode>
): MutableMap<String, JsonNode> {
return resolvePropertyAssignments(
- BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE,
relationshipTemplateName, propertyDefinitions, propertyAssignments
)
}
override fun setInputValue(propertyName: String, value: JsonNode) {
- val path = """${BluePrintConstants.PATH_INPUTS}${BluePrintConstants.PATH_DIVIDER}$propertyName"""
+ val path = """${BlueprintConstants.PATH_INPUTS}${BlueprintConstants.PATH_DIVIDER}$propertyName"""
put(path, value)
}
propertyDefinition: PropertyDefinition,
value: JsonNode
) {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_WORKFLOWS)
- .append(BluePrintConstants.PATH_DIVIDER).append(workflowName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_INPUTS)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_WORKFLOWS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(workflowName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_INPUTS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
put(path, value)
}
override fun setNodeTemplatePropertyValue(nodeTemplateName: String, propertyName: String, value: JsonNode) {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
put(path, value)
}
override fun setNodeTemplateAttributeValue(nodeTemplateName: String, attributeName: String, value: JsonNode) {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_ATTRIBUTES)
- .append(BluePrintConstants.PATH_DIVIDER).append(attributeName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_ATTRIBUTES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(attributeName).toString()
put(path, value)
}
propertyName: String,
value: JsonNode
) {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_INTERFACES)
- .append(BluePrintConstants.PATH_DIVIDER).append(interfaceName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_OPERATIONS)
- .append(BluePrintConstants.PATH_DIVIDER).append(operationName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_INTERFACES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(interfaceName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_OPERATIONS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(operationName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
log.trace("setting operation property path ({}), values ({})", path, value)
put(path, value)
}
propertyName: String,
value: JsonNode
) {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_INTERFACES)
- .append(BluePrintConstants.PATH_DIVIDER).append(interfaceName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_OPERATIONS)
- .append(BluePrintConstants.PATH_DIVIDER).append(operationName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_INPUTS)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_INTERFACES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(interfaceName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_OPERATIONS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(operationName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_INPUTS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
put(path, value)
}
propertyName: String,
value: JsonNode
) {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_INTERFACES)
- .append(BluePrintConstants.PATH_DIVIDER).append(interfaceName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_OPERATIONS)
- .append(BluePrintConstants.PATH_DIVIDER).append(operationName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_OUTPUTS)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_INTERFACES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(interfaceName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_OPERATIONS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(operationName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_OUTPUTS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
put(path, value)
}
override fun getInputValue(propertyName: String): JsonNode {
- val path = StringBuilder(BluePrintConstants.PATH_INPUTS)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path = StringBuilder(BlueprintConstants.PATH_INPUTS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
return getJsonNode(path)
}
operationName: String,
propertyName: String
): JsonNode {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_INTERFACES)
- .append(BluePrintConstants.PATH_DIVIDER).append(interfaceName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_OPERATIONS)
- .append(BluePrintConstants.PATH_DIVIDER).append(operationName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_OUTPUTS)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_INTERFACES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(interfaceName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_OPERATIONS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(operationName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_OUTPUTS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
return getJsonNode(path)
}
override fun getNodeTemplatePropertyValue(nodeTemplateName: String, propertyName: String): JsonNode {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
return getJsonNode(path)
}
override fun getNodeTemplateAttributeValue(nodeTemplateName: String, attributeName: String): JsonNode {
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_ATTRIBUTES)
- .append(BluePrintConstants.PATH_DIVIDER).append(attributeName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_ATTRIBUTES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(attributeName).toString()
return getJsonNode(path)
}
relationshipTemplateName: String,
propertyName: String
): JsonNode? {
- val path: String = StringBuilder(BluePrintConstants.PATH_RELATIONSHIP_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(relationshipTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_PROPERTIES)
- .append(BluePrintConstants.PATH_DIVIDER).append(propertyName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_RELATIONSHIP_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(relationshipTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_PROPERTIES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(propertyName).toString()
return getJsonNode(path)
}
relationshipTemplateName: String,
attributeName: String
): JsonNode? {
- val path: String = StringBuilder(BluePrintConstants.PATH_RELATIONSHIP_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(relationshipTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_ATTRIBUTES)
- .append(BluePrintConstants.PATH_DIVIDER).append(attributeName).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_RELATIONSHIP_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(relationshipTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_ATTRIBUTES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(attributeName).toString()
return getJsonNode(path)
}
override fun assignInputs(jsonNode: JsonNode) {
log.info("assignInputs from input JSON ({})", jsonNode.toString())
bluePrintContext.inputs()?.forEach { propertyName, property ->
- val valueNode: JsonNode = jsonNode.at(BluePrintConstants.PATH_DIVIDER + propertyName)
+ val valueNode: JsonNode = jsonNode.at(BlueprintConstants.PATH_DIVIDER + propertyName)
?: property.defaultValue
?: NullNode.getInstance()
setInputValue(propertyName, valueNode)
}
private fun findAndSetInputValue(propertyName: String, property: PropertyDefinition, jsonNode: JsonNode) {
- val valueNode = jsonNode.at(BluePrintConstants.PATH_DIVIDER + propertyName)
+ val valueNode = jsonNode.at(BlueprintConstants.PATH_DIVIDER + propertyName)
.returnNullIfMissing()
?: property.defaultValue
?: NullNode.getInstance()
override fun getJsonForNodeTemplateAttributeProperties(nodeTemplateName: String, keys: List<String>): JsonNode {
val jsonNode: ObjectNode = jacksonObjectMapper().createObjectNode()
- val path: String = StringBuilder(BluePrintConstants.PATH_NODE_TEMPLATES)
- .append(BluePrintConstants.PATH_DIVIDER).append(nodeTemplateName)
- .append(BluePrintConstants.PATH_DIVIDER).append(BluePrintConstants.PATH_ATTRIBUTES)
- .append(BluePrintConstants.PATH_DIVIDER).toString()
+ val path: String = StringBuilder(BlueprintConstants.PATH_NODE_TEMPLATES)
+ .append(BlueprintConstants.PATH_DIVIDER).append(nodeTemplateName)
+ .append(BlueprintConstants.PATH_DIVIDER).append(BlueprintConstants.PATH_ATTRIBUTES)
+ .append(BlueprintConstants.PATH_DIVIDER).toString()
store.keys.filter {
it.startsWith(path)
}.map {
*/
package org.onap.ccsdk.cds.controllerblueprints.core.service
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTemplateService
import org.springframework.stereotype.Service
@Service
-class BluePrintTemplateService(private val bluePrintLoadConfiguration: BluePrintLoadConfiguration) :
+class BlueprintTemplateService(private val bluePrintLoadConfiguration: BlueprintLoadConfiguration) :
BlueprintTemplateService {
override suspend fun generateContent(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
nodeTemplateName: String,
artifactName: String,
jsonData: String,
val template = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactName)
return when (templateType) {
- BluePrintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_JINJA -> {
- BluePrintJinjaTemplateService.generateContent(
+ BlueprintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_JINJA -> {
+ BlueprintJinjaTemplateService.generateContent(
template,
jsonData,
ignoreJsonNull,
bluePrintRuntimeService.bluePrintContext().version()
)
}
- BluePrintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_VELOCITY -> {
- BluePrintVelocityTemplateService.generateContent(template, jsonData, ignoreJsonNull, additionalContext)
+ BlueprintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_VELOCITY -> {
+ BlueprintVelocityTemplateService.generateContent(template, jsonData, ignoreJsonNull, additionalContext)
}
else -> {
- throw BluePrintProcessorException(
- "Unknown Artifact type, expecting ${BluePrintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_JINJA}" +
- "or ${BluePrintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_VELOCITY}"
+ throw BlueprintProcessorException(
+ "Unknown Artifact type, expecting ${BlueprintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_JINJA}" +
+ "or ${BlueprintConstants.MODEL_TYPE_ARTIFACT_TEMPLATE_VELOCITY}"
)
}
}
import com.fasterxml.jackson.databind.JsonNode
import com.google.common.base.Preconditions
import org.apache.commons.lang3.StringUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
*
* @author Brinda Santh
*/
-interface BluePrintValidatorService : Serializable {
+interface BlueprintValidatorService : Serializable {
- @Throws(BluePrintException::class)
- fun validateBlueprint(bluePrintContext: BluePrintContext, properties: MutableMap<String, Any>)
+ @Throws(BlueprintException::class)
+ fun validateBlueprint(bluePrintContext: BlueprintContext, properties: MutableMap<String, Any>)
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun validateBlueprint(serviceTemplate: ServiceTemplate, properties: MutableMap<String, Any>)
}
@Deprecated("Decomposed implementation moved to blueprint-validation module")
-open class BluePrintValidatorDefaultService : BluePrintValidatorService {
+open class BlueprintValidatorDefaultService : BlueprintValidatorService {
- val log = LoggerFactory.getLogger(BluePrintValidatorDefaultService::class.toString())
+ val log = LoggerFactory.getLogger(BlueprintValidatorDefaultService::class.toString())
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintContext: BlueprintContext
lateinit var serviceTemplate: ServiceTemplate
lateinit var properties: MutableMap<String, Any>
var message: StringBuilder = StringBuilder()
- private val separator: String = BluePrintConstants.PATH_DIVIDER
+ private val separator: String = BlueprintConstants.PATH_DIVIDER
var paths: MutableList<String> = arrayListOf()
- @Throws(BluePrintException::class)
- override fun validateBlueprint(bluePrintContext: BluePrintContext, properties: MutableMap<String, Any>) {
+ @Throws(BlueprintException::class)
+ override fun validateBlueprint(bluePrintContext: BlueprintContext, properties: MutableMap<String, Any>) {
validateBlueprint(bluePrintContext.serviceTemplate, properties)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
override fun validateBlueprint(serviceTemplate: ServiceTemplate, properties: MutableMap<String, Any>) {
- this.bluePrintContext = BluePrintContext(serviceTemplate)
+ this.bluePrintContext = BlueprintContext(serviceTemplate)
this.serviceTemplate = serviceTemplate
this.properties = properties
try {
} catch (e: Exception) {
log.error("validation failed in the path : {}", paths.joinToString(separator), e)
log.error("validation trace message :{} ", message)
- throw BluePrintException(
+ throw BlueprintException(
e,
format("failed to validate blueprint on path ({}) with message {}", paths.joinToString(separator), e.message)
)
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateMetadata(metaDataMap: MutableMap<String, String>) {
paths.add("metadata")
- val templateName = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_NAME]
- val templateVersion = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_VERSION]
- val templateTags = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_TAGS]
- val templateAuthor = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_AUTHOR]
+ val templateName = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_NAME]
+ val templateVersion = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_VERSION]
+ val templateTags = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_TAGS]
+ val templateAuthor = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_AUTHOR]
Preconditions.checkArgument(StringUtils.isNotBlank(templateName), "failed to get template name metadata")
Preconditions.checkArgument(StringUtils.isNotBlank(templateVersion), "failed to get template version metadata")
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateArtifactTypes(artifactTypes: MutableMap<String, ArtifactType>) {
paths.add("artifact_types")
artifactTypes.forEach { artifactName, artifactType ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateDataTypes(dataTypes: MutableMap<String, DataType>) {
paths.add("dataTypes")
dataTypes.forEach { dataTypeName, dataType ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateNodeTypes(nodeTypes: MutableMap<String, NodeType>) {
paths.add("nodeTypes")
nodeTypes.forEach { nodeTypeName, nodeType ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateNodeType(nodeTypeName: String, nodeType: NodeType) {
paths.add(nodeTypeName)
message.appendln("--> Node Type :" + paths.joinToString(separator))
// Check Derived From
checkValidNodeTypesDerivedFrom(nodeTypeName, derivedFrom)
- if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {
+ if (!BlueprintTypes.rootNodeTypes().contains(derivedFrom)) {
serviceTemplate.nodeTypes?.get(derivedFrom)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get derivedFrom NodeType({})'s for NodeType({}) ",
derivedFrom, nodeTypeName
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun checkValidNodeTypesDerivedFrom(nodeTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validNodeTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException(format("Failed to get node type ({})'s derivedFrom({}) definition ", nodeTypeName, derivedFrom))
+ check(BlueprintTypes.validNodeTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException(format("Failed to get node type ({})'s derivedFrom({}) definition ", nodeTypeName, derivedFrom))
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateTopologyTemplate(topologyTemplate: TopologyTemplate) {
paths.add("topology")
message.appendln("--> Topology Template")
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInputs(inputs: MutableMap<String, PropertyDefinition>) {
paths.add("inputs")
message.appendln("---> Input :" + paths.joinToString(separator))
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateNodeTemplates(nodeTemplates: MutableMap<String, NodeTemplate>) {
paths.add("nodeTemplates")
nodeTemplates.forEach { nodeTemplateName, nodeTemplate ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate) {
paths.add(nodeTemplateName)
message.appendln("---> NodeTemplate :" + paths.joinToString(separator))
val type: String = nodeTemplate.type
val nodeType: NodeType = serviceTemplate.nodeTypes?.get(type)
- ?: throw BluePrintException(format("Failed to get NodeType({}) definition for NodeTemplate({})", type, nodeTemplateName))
+ ?: throw BlueprintException(format("Failed to get NodeType({}) definition for NodeTemplate({})", type, nodeTemplateName))
nodeTemplate.artifacts?.let { validateArtifactDefinitions(nodeTemplate.artifacts!!) }
nodeTemplate.properties?.let { validatePropertyAssignments(nodeType.properties!!, nodeTemplate.properties!!) }
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateArtifactDefinitions(artifacts: MutableMap<String, ArtifactDefinition>) {
paths.add("artifacts")
artifacts.forEach { artifactDefinitionName, artifactDefinition ->
paths.add(artifactDefinitionName)
message.appendln("Validating artifact " + paths.joinToString(separator))
val type: String = artifactDefinition.type
- ?: throw BluePrintException(format("type is missing for ArtifactDefinition({})", artifactDefinitionName))
+ ?: throw BlueprintException(format("type is missing for ArtifactDefinition({})", artifactDefinitionName))
// Check Artifact Type
checkValidArtifactType(artifactDefinitionName, type)
val file: String = artifactDefinition.file
- ?: throw BluePrintException(format("file is missing for ArtifactDefinition({})", artifactDefinitionName))
+ ?: throw BlueprintException(format("file is missing for ArtifactDefinition({})", artifactDefinitionName))
paths.removeAt(paths.lastIndex)
}
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateWorkFlows(workflows: MutableMap<String, Workflow>) {
paths.add("workflows")
workflows.forEach { workflowName, workflow ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateWorkFlow(workflowName: String, workflow: Workflow) {
paths.add(workflowName)
message.appendln("---> Workflow :" + paths.joinToString(separator))
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validatePropertyDefinitions(properties: MutableMap<String, PropertyDefinition>) {
paths.add("properties")
properties.forEach { propertyName, propertyDefinition ->
paths.add(propertyName)
val dataType: String = propertyDefinition.type
when {
- BluePrintTypes.validPrimitiveTypes().contains(dataType) -> {
+ BlueprintTypes.validPrimitiveTypes().contains(dataType) -> {
// Do Nothing
}
- BluePrintTypes.validCollectionTypes().contains(dataType) -> {
+ BlueprintTypes.validCollectionTypes().contains(dataType) -> {
val entrySchemaType: String = propertyDefinition.entrySchema?.type
- ?: throw BluePrintException(format("Entry schema for DataType ({}) for the property ({}) not found", dataType, propertyName))
+ ?: throw BlueprintException(format("Entry schema for DataType ({}) for the property ({}) not found", dataType, propertyName))
checkPrimitiveOrComplex(entrySchemaType, propertyName)
}
else -> checkPropertyDataType(dataType, propertyName)
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validatePropertyAssignments(
nodeTypeProperties: MutableMap<String, PropertyDefinition>,
properties: MutableMap<String, JsonNode>
) {
properties.forEach { propertyName, propertyAssignment ->
val propertyDefinition: PropertyDefinition = nodeTypeProperties[propertyName]
- ?: throw BluePrintException(format("failed to get definition for the property ({})", propertyName))
+ ?: throw BlueprintException(format("failed to get definition for the property ({})", propertyName))
validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validatePropertyAssignment(
propertyName: String,
propertyDefinition: PropertyDefinition,
propertyAssignment: JsonNode
) {
// Check and Validate if Expression Node
- val expressionData = BluePrintExpressionService.getExpressionData(propertyAssignment)
+ val expressionData = BlueprintExpressionService.getExpressionData(propertyAssignment)
if (!expressionData.isExpression) {
checkPropertyValue(propertyName, propertyDefinition, propertyAssignment)
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateCapabilityAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
val capabilities = nodeTemplate.capabilities
paths.add("capabilities")
paths.add(capabilityName)
val capabilityDefinition = nodeType.capabilities?.get(capabilityName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get NodeTemplate({}) capability definition ({}) " +
"from NodeType({}) ",
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateCapabilityAssignment(
nodeTemplateName: String,
capabilityName: String,
capabilityAssignment.properties?.let { validatePropertyAssignments(capabilityDefinition.properties!!, capabilityAssignment.properties!!) }
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateRequirementAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
val requirements = nodeTemplate.requirements
paths.add("requirements")
requirements?.forEach { requirementName, requirementAssignment ->
paths.add(requirementName)
val requirementDefinition = nodeType.requirements?.get(requirementName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get NodeTemplate({}) requirement definition ({}) from" +
" NodeType({}) ",
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateRequirementAssignment(
nodeTemplateName: String,
requirementAssignmentName: String,
val capabilityName = requirementAssignment.capability
val relationship = requirementAssignment.relationship!!
- check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {
- throw BluePrintException(
+ check(BlueprintTypes.validRelationShipDerivedFroms.contains(relationship)) {
+ throw BlueprintException(
format(
"Failed to get relationship type ({}) for NodeTemplate({})'s requirement({}) ",
relationship, nodeTemplateName, requirementAssignmentName
}
val relationShipNodeTemplate = serviceTemplate.topologyTemplate?.nodeTemplates?.get(requirementNodeTemplateName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get requirement NodeTemplate({})'s for NodeTemplate({}) requirement({}) ",
requirementNodeTemplateName, nodeTemplateName, requirementAssignmentName
)
relationShipNodeTemplate.capabilities?.get(capabilityName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get requirement NodeTemplate({})'s capability({}) for NodeTemplate ({})'s requirement({}) ",
requirementNodeTemplateName, capabilityName, nodeTemplateName, requirementAssignmentName
)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInterfaceAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
val interfaces = nodeTemplate.interfaces
interfaces?.forEach { interfaceAssignmentName, interfaceAssignment ->
paths.add(interfaceAssignmentName)
val interfaceDefinition = nodeType.interfaces?.get(interfaceAssignmentName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get NodeTemplate({}) interface definition ({}) from" +
" NodeType({}) ",
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInterfaceAssignment(
nodeTemplateName: String,
interfaceAssignmentName: String,
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInterfaceOperationsAssignment(
nodeTemplateName: String,
interfaceAssignmentName: String,
it.forEach { operationAssignmentName, operationAssignments ->
val operationDefinition = interfaceDefinition.operations?.get(operationAssignmentName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get NodeTemplate({}) operation definition ({}) ",
nodeTemplateName, operationAssignmentName
inputs?.forEach { propertyName, propertyAssignment ->
val propertyDefinition = operationDefinition.inputs?.get(propertyName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get NodeTemplate({}) operation definition ({}) " +
"property definition({})",
outputs?.forEach { propertyName, propertyAssignment ->
val propertyDefinition = operationDefinition.outputs?.get(propertyName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get NodeTemplate({}) operation definition ({}) " +
"output property definition({})",
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateCapabilityDefinitions(nodeTypeName: String, nodeType: NodeType) {
val capabilities = nodeType.capabilities
paths.add("capabilities")
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateCapabilityDefinition(
nodeTypeName: String,
nodeType: NodeType,
capabilityDefinition: CapabilityDefinition
) {
val capabilityType = capabilityDefinition.type
- check(BluePrintTypes.validCapabilityTypes.contains(capabilityType)) {
- throw BluePrintException(
+ check(BlueprintTypes.validCapabilityTypes.contains(capabilityType)) {
+ throw BlueprintException(
format(
"Failed to get CapabilityType({}) for NodeType({})",
capabilityType, nodeTypeName
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateRequirementDefinitions(nodeName: String, nodeType: NodeType) {
paths.add("requirements")
val requirements = nodeType.requirements
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateRequirementDefinition(
nodeTypeName: String,
nodeType: NodeType,
val capabilityName = requirementDefinition.capability
val relationship = requirementDefinition.relationship!!
- check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {
- throw BluePrintException(
+ check(BlueprintTypes.validRelationShipDerivedFroms.contains(relationship)) {
+ throw BlueprintException(
format(
"Failed to get relationship({}) for NodeType({})'s requirement({}) ",
relationship, nodeTypeName, requirementDefinitionName
}
val relationShipNodeType = serviceTemplate.nodeTypes?.get(requirementNodeTypeName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get requirement NodeType({})'s for requirement({}) ",
requirementNodeTypeName, requirementDefinitionName
)
relationShipNodeType.capabilities?.get(capabilityName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"Failed to get requirement NodeType({})'s capability({}) for NodeType ({})'s requirement({}) ",
requirementNodeTypeName, capabilityName, nodeTypeName, requirementDefinitionName
)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInterfaceDefinitions(interfaces: MutableMap<String, InterfaceDefinition>) {
paths.add("interfaces")
interfaces.forEach { interfaceName, interfaceDefinition ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateOperationDefinitions(operations: MutableMap<String, OperationDefinition>) {
paths.add("operations")
operations.forEach { opertaionName, operationDefinition ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateImplementation(implementation: Implementation) {
checkNotEmpty(implementation.primary) { "couldn't get implementation" }
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun checkValidArtifactType(artifactDefinitionName: String, artifactTypeName: String) {
val artifactType = serviceTemplate.artifactTypes?.get(artifactTypeName)
- ?: throw BluePrintException("failed to artifactType($artifactTypeName) for ArtifactDefinition($artifactDefinitionName)")
+ ?: throw BlueprintException("failed to artifactType($artifactTypeName) for ArtifactDefinition($artifactDefinitionName)")
checkValidArtifactTypeDerivedFrom(artifactTypeName, artifactType.derivedFrom)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun checkValidArtifactTypeDerivedFrom(artifactTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validArtifactTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException("failed to get artifactType($artifactTypeName)'s derivedFrom($derivedFrom) definition")
+ check(BlueprintTypes.validArtifactTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException("failed to get artifactType($artifactTypeName)'s derivedFrom($derivedFrom) definition")
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun checkValidDataTypeDerivedFrom(dataTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException(format("Failed to get DataType({})'s derivedFrom({}) definition ", dataTypeName, derivedFrom))
+ check(BlueprintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException(format("Failed to get DataType({})'s derivedFrom({}) definition ", dataTypeName, derivedFrom))
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun checkValidRelationshipTypeDerivedFrom(relationshipTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validRelationShipDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException(format("Failed to get relationship type ({})'s derivedFrom({}) definition ", relationshipTypeName, derivedFrom))
+ check(BlueprintTypes.validRelationShipDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException(format("Failed to get relationship type ({})'s derivedFrom({}) definition ", relationshipTypeName, derivedFrom))
}
}
val propertyType = propertyDefinition.type
val isValid: Boolean
- if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {
+ if (BlueprintTypes.validPrimitiveTypes().contains(propertyType)) {
isValid = JacksonUtils.checkJsonNodeValueOfPrimitiveType(propertyType, propertyAssignment)
- } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {
+ } else if (BlueprintTypes.validCollectionTypes().contains(propertyType)) {
val entrySchemaType = propertyDefinition.entrySchema?.type
- ?: throw BluePrintException(format("Failed to get EntrySchema type for the collection property ({})", propertyName))
+ ?: throw BlueprintException(format("Failed to get EntrySchema type for the collection property ({})", propertyName))
- if (!BluePrintTypes.validPropertyTypes().contains(entrySchemaType)) {
+ if (!BlueprintTypes.validPropertyTypes().contains(entrySchemaType)) {
checkPropertyDataType(entrySchemaType, propertyName)
}
isValid = JacksonUtils.checkJsonNodeValueOfCollectionType(propertyType, propertyAssignment)
}
check(isValid) {
- throw BluePrintException(
+ throw BlueprintException(
format(
"property({}) defined of type({}) is not comptable with the value ({})",
propertyName, propertyType, propertyAssignment
private fun checkPropertyDataType(dataTypeName: String, propertyName: String) {
val dataType = serviceTemplate.dataTypes?.get(dataTypeName)
- ?: throw BluePrintException(format("DataType ({}) for the property ({}) not found", dataTypeName, propertyName))
+ ?: throw BlueprintException(format("DataType ({}) for the property ({}) not found", dataTypeName, propertyName))
checkValidDataTypeDerivedFrom(propertyName, dataType.derivedFrom)
}
private fun checkPrimitiveOrComplex(dataType: String, propertyName: String): Boolean {
- if (BluePrintTypes.validPrimitiveTypes().contains(dataType) || checkDataType(dataType)) {
+ if (BlueprintTypes.validPrimitiveTypes().contains(dataType) || checkDataType(dataType)) {
return true
} else {
- throw BluePrintException(format("DataType({}) for the property({}) is not valid", dataType, propertyName))
+ throw BlueprintException(format("DataType({}) for the property({}) is not valid", dataType, propertyName))
}
}
import org.apache.commons.lang3.StringUtils
import org.apache.velocity.VelocityContext
import org.apache.velocity.app.VelocityEngine
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintJsonNodeFactory
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintJsonNodeFactory
import org.onap.ccsdk.cds.controllerblueprints.core.removeNullNode
import java.io.StringWriter
-object BluePrintVelocityTemplateService {
+object BlueprintVelocityTemplateService {
/**
* Generate Content from Velocity Template and JSON Content with injected API
// Customized Object Mapper to remove String double quotes
val mapper = ObjectMapper()
- val nodeFactory = BluePrintJsonNodeFactory()
+ val nodeFactory = BlueprintJsonNodeFactory()
mapper.nodeFactory = nodeFactory
val jsonNode: JsonNode? = if (json.isNotEmpty()) {
mapper.readValue(json, JsonNode::class.java)
- ?: throw BluePrintProcessorException("couldn't get json node from json")
+ ?: throw BlueprintProcessorException("couldn't get json node from json")
} else {
null
}
import kotlinx.coroutines.channels.actor
import kotlinx.coroutines.channels.consumeEach
import kotlinx.coroutines.launch
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.data.EdgeLabel
import org.onap.ccsdk.cds.controllerblueprints.core.data.EdgeStatus
import org.onap.ccsdk.cds.controllerblueprints.core.data.Graph
import org.onap.ccsdk.cds.controllerblueprints.core.startNodes
import kotlin.coroutines.CoroutineContext
-interface BluePrintWorkFlowService<In, Out> {
+interface BlueprintWorkFlowService<In, Out> {
/** Executes imperative workflow graph [graph] for the bluePrintRuntimeService [bluePrintRuntimeService]
* and workflow input [input]*/
- suspend fun executeWorkflow(graph: Graph, bluePrintRuntimeService: BluePrintRuntimeService<*>, input: In): Out
+ suspend fun executeWorkflow(graph: Graph, bluePrintRuntimeService: BlueprintRuntimeService<*>, input: In): Out
suspend fun initializeWorkflow(input: In): EdgeLabel
}
/** Abstract workflow service implementation */
-abstract class AbstractBluePrintWorkFlowService<In, Out> : CoroutineScope, BluePrintWorkFlowService<In, Out> {
+abstract class AbstractBlueprintWorkFlowService<In, Out> : CoroutineScope, BlueprintWorkFlowService<In, Out> {
lateinit var graph: Graph
- private val log = logger(AbstractBluePrintWorkFlowService::class)
+ private val log = logger(AbstractBlueprintWorkFlowService::class)
private val job = Job()
// Wait for workflow completion or Error
nodeActor.invokeOnClose { exception ->
launch {
- if (exception != null) exceptions.add(BluePrintProcessorException(exception))
+ if (exception != null) exceptions.add(BlueprintProcessorException(exception))
log.info("workflow($workflowId) nodes completed with (${exceptions.size})exceptions")
val workflowOutput = prepareWorkflowOutput()
workflowExecuteMessage.output.complete(workflowOutput)
suspend fun executeNodeWorker(message: NodeExecuteMessage<In, Out>) {
val node = message.node
node.status = NodeStatus.EXECUTING
- val nodeState = if (node.id == BluePrintConstants.GRAPH_START_NODE_NAME ||
- node.id == BluePrintConstants.GRAPH_END_NODE_NAME
+ val nodeState = if (node.id == BlueprintConstants.GRAPH_START_NODE_NAME ||
+ node.id == BlueprintConstants.GRAPH_END_NODE_NAME
) {
EdgeLabel.SUCCESS
} else {
// Close the current channel
channel.close()
} else if (!edgePresent) {
- throw BluePrintProcessorException("node(${node.id}) outgoing edge($nodeState) is missing.")
+ throw BlueprintProcessorException("node(${node.id}) outgoing edge($nodeState) is missing.")
} else {
val skippingEdges = graph.outgoingEdgesNotInLabels(node.id, arrayListOf(nodeState))
log.debug("Skipping node($node)'s outgoing edges($skippingEdges)")
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactExpression
*
* @author Brinda Santh
*/
-open class PropertyAssignmentService(var bluePrintRuntimeService: BluePrintRuntimeService<MutableMap<String, JsonNode>>) {
+open class PropertyAssignmentService(var bluePrintRuntimeService: BlueprintRuntimeService<MutableMap<String, JsonNode>>) {
private val log = LoggerFactory.getLogger(this::class.toString())
- private var bluePrintContext: BluePrintContext = bluePrintRuntimeService.bluePrintContext()
+ private var bluePrintContext: BlueprintContext = bluePrintRuntimeService.bluePrintContext()
/*
assignment: JsonNode
): JsonNode {
log.trace("Assignment ({})", assignment)
- val expressionData = BluePrintExpressionService.getExpressionData(assignment)
+ val expressionData = BlueprintExpressionService.getExpressionData(assignment)
return if (expressionData.isExpression) {
resolveExpression(definitionType, definitionName, assignmentName, expressionData)
val command = expressionData.command!!
when (command) {
- BluePrintConstants.EXPRESSION_GET_INPUT -> {
+ BlueprintConstants.EXPRESSION_GET_INPUT -> {
valueNode = bluePrintRuntimeService.getInputValue(expressionData.inputExpression?.propertyName!!)
}
- BluePrintConstants.EXPRESSION_GET_ATTRIBUTE -> {
+ BlueprintConstants.EXPRESSION_GET_ATTRIBUTE -> {
valueNode =
resolveAttributeExpression(definitionType, definitionName, expressionData.attributeExpression!!)
}
- BluePrintConstants.EXPRESSION_GET_PROPERTY -> {
+ BlueprintConstants.EXPRESSION_GET_PROPERTY -> {
valueNode =
resolvePropertyExpression(definitionType, definitionName, expressionData.propertyExpression!!)
}
- BluePrintConstants.EXPRESSION_GET_OPERATION_OUTPUT -> {
+ BlueprintConstants.EXPRESSION_GET_OPERATION_OUTPUT -> {
valueNode =
resolveOperationOutputExpression(definitionName, expressionData.operationOutputExpression!!)
}
- BluePrintConstants.EXPRESSION_GET_ARTIFACT -> {
+ BlueprintConstants.EXPRESSION_GET_ARTIFACT -> {
valueNode = resolveArtifactExpression(definitionName, expressionData.artifactExpression!!)
}
- BluePrintConstants.EXPRESSION_DSL_REFERENCE -> {
+ BlueprintConstants.EXPRESSION_DSL_REFERENCE -> {
valueNode =
bluePrintRuntimeService.resolveDSLExpression(expressionData.dslExpression!!.propertyName)
}
- BluePrintConstants.EXPRESSION_GET_NODE_OF_TYPE -> {
+ BlueprintConstants.EXPRESSION_GET_NODE_OF_TYPE -> {
}
else -> {
- throw BluePrintException(
+ throw BlueprintException(
"for $definitionType($definitionName) property ($propName), " +
"command ($command) is not supported "
)
* SELF : Current Node Template properties.
*/
when (attributeExpression.modelableEntityName) {
- BluePrintConstants.PROPERTY_ENV -> {
+ BlueprintConstants.PROPERTY_ENV -> {
val environmentValue = System.getenv(attributeName)
valueNode = environmentValue.asJsonPrimitive()
}
- BluePrintConstants.PROPERTY_APP -> {
+ BlueprintConstants.PROPERTY_APP -> {
val environmentValue = System.getProperty(attributeName)
valueNode = environmentValue.asJsonPrimitive()
}
- BluePrintConstants.PROPERTY_BPP -> {
+ BlueprintConstants.PROPERTY_BPP -> {
valueNode = bluePrintRuntimeService.getNodeTemplateAttributeValue(
- BluePrintConstants.PROPERTY_BPP,
+ BlueprintConstants.PROPERTY_BPP,
attributeName
- ) ?: throw BluePrintException("failed to get env attribute name ($attributeName) ")
+ ) ?: throw BlueprintException("failed to get env attribute name ($attributeName) ")
}
else -> {
- if (!attributeExpression.modelableEntityName.equals(BluePrintConstants.PROPERTY_SELF, true)) {
+ if (!attributeExpression.modelableEntityName.equals(BlueprintConstants.PROPERTY_SELF, true)) {
attributeDefinitionName = attributeExpression.modelableEntityName
}
/** This block is to Validate, if Attribute definition is present */
when (definitionType) {
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
- BluePrintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
- BluePrintConstants.MODEL_DEFINITION_TYPE_DSL ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DSL ->
bluePrintContext.nodeTemplateNodeType(attributeDefinitionName).attributes
- BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
bluePrintContext.relationshipTemplateRelationshipType(attributeDefinitionName).attributes
- else -> throw BluePrintException("failed to understand template type($definitionType), it is not supported")
+ else -> throw BlueprintException("failed to understand template type($definitionType), it is not supported")
}?.get(attributeName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"failed to get attribute definitions for " +
"$definitionType ($attributeDefinitionName)'s attribute name ($attributeName) "
)
valueNode = when (definitionType) {
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
- BluePrintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
- BluePrintConstants.MODEL_DEFINITION_TYPE_DSL ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DSL ->
bluePrintRuntimeService.getNodeTemplateAttributeValue(attributeDefinitionName, attributeName)
- BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
bluePrintRuntimeService.getRelationshipTemplateAttributeValue(
attributeDefinitionName,
attributeName
)
- else -> throw BluePrintException("failed to understand template type($definitionType), it is not supported")
+ else -> throw BlueprintException("failed to understand template type($definitionType), it is not supported")
}
- ?: throw BluePrintException("failed to get node template ($attributeDefinitionName)'s attribute name ($attributeName) ")
+ ?: throw BlueprintException("failed to get node template ($attributeDefinitionName)'s attribute name ($attributeName) ")
}
}
if (subAttributeName != null) {
var propertyDefinitionName = definitionName
- if (!propertyExpression.modelableEntityName.equals(BluePrintConstants.PROPERTY_SELF, true)) {
+ if (!propertyExpression.modelableEntityName.equals(BlueprintConstants.PROPERTY_SELF, true)) {
propertyDefinitionName = propertyExpression.modelableEntityName
}
val nodeTemplatePropertyExpression = when (definitionType) {
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
- BluePrintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
- BluePrintConstants.MODEL_DEFINITION_TYPE_DSL ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DSL ->
bluePrintContext.nodeTemplateByName(propertyDefinitionName).properties
- BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
bluePrintContext.relationshipTemplateByName(propertyDefinitionName).properties
- else -> throw BluePrintException("failed to understand template type($definitionType), it is not supported")
+ else -> throw BlueprintException("failed to understand template type($definitionType), it is not supported")
}?.get(propertyName)
- ?: throw BluePrintException("failed to get property assignment for node template ($definitionName)'s property name ($propertyName).")
+ ?: throw BlueprintException("failed to get property assignment for node template ($definitionName)'s property name ($propertyName).")
/** This block is to Validate, if Property definition is present */
when (definitionType) {
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
- BluePrintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
- BluePrintConstants.MODEL_DEFINITION_TYPE_DSL ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_WORKFLOW,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DSL ->
bluePrintContext.nodeTemplateNodeType(propertyDefinitionName).properties
- BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
+ BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TEMPLATE ->
bluePrintContext.relationshipTemplateRelationshipType(propertyDefinitionName).properties
- else -> throw BluePrintException("failed to understand template type($definitionType), it is not supported")
+ else -> throw BlueprintException("failed to understand template type($definitionType), it is not supported")
}?.get(propertyName)
- ?: throw BluePrintException("failed to get property definition for node template ($definitionName)'s property name ($propertyName).")
+ ?: throw BlueprintException("failed to get property definition for node template ($definitionName)'s property name ($propertyName).")
log.info(
"$definitionType($propertyDefinitionName), property($propertyName) resolved value ($nodeTemplatePropertyExpression)"
}
val artifactDefinition: ArtifactDefinition = bluePrintContext.nodeTemplateByName(artifactNodeTemplateName)
.artifacts?.get(artifactExpression.artifactName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
format(
"failed to get artifact definitions for node template ({})'s " +
"artifact name ({}) ",
import org.apache.commons.compress.archivers.zip.ZipFile
import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.slf4j.LoggerFactory
import java.io.BufferedInputStream
import java.io.ByteArrayInputStream
Zip
}
-class BluePrintArchiveUtils {
+class BlueprintArchiveUtils {
companion object {
- private val log = LoggerFactory.getLogger(BluePrintArchiveUtils::class.java)
+ private val log = LoggerFactory.getLogger(BlueprintArchiveUtils::class.java)
/**
* Create a new Zip from a root directory
val destinationDir = File(targetPath)
check(destinationDir.isDirectory && destinationDir.exists()) {
- throw BluePrintProcessorException("failed to decompress blueprint(${archiveFile.absolutePath}) to ($targetPath) ")
+ throw BlueprintProcessorException("failed to decompress blueprint(${archiveFile.absolutePath}) to ($targetPath) ")
}
return destinationDir
import kotlinx.coroutines.runBlocking
import org.apache.commons.io.FileUtils
import org.apache.commons.lang3.StringUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ErrorCode
import org.onap.ccsdk.cds.controllerblueprints.core.data.ImportDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.slf4j.LoggerFactory
import java.io.File
import java.io.FileFilter
import java.nio.file.Paths
import java.nio.file.StandardOpenOption
-class BluePrintFileUtils {
+class BlueprintFileUtils {
companion object {
const val COMPILED_JAR_SUFFIX = "cba-kts.jar"
private val log = LoggerFactory.getLogger(this::class.toString())
- fun createEmptyBluePrint(basePath: String) {
+ fun createEmptyBlueprint(basePath: String) {
val blueprintDir = File(basePath)
FileUtils.deleteDirectory(blueprintDir)
Files.createDirectories(blueprintDir.toPath())
- val metaDataDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_METADATA_DIR))
+ val metaDataDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BlueprintConstants.TOSCA_METADATA_DIR))
Files.createDirectories(metaDataDir.toPath())
val metaFile = File(
blueprintDir.absolutePath.plus(File.separator).plus(
- BluePrintConstants
+ BlueprintConstants
.TOSCA_METADATA_ENTRY_DEFINITION_FILE
)
)
Files.write(metaFile.toPath(), getMetaDataContent().toByteArray(), StandardOpenOption.CREATE_NEW)
- val definitionsDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR))
+ val definitionsDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BlueprintConstants.TOSCA_DEFINITIONS_DIR))
Files.createDirectories(definitionsDir.toPath())
- val scriptsDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_SCRIPTS_DIR))
+ val scriptsDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BlueprintConstants.TOSCA_SCRIPTS_DIR))
Files.createDirectories(scriptsDir.toPath())
- val plansDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_PLANS_DIR))
+ val plansDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BlueprintConstants.TOSCA_PLANS_DIR))
Files.createDirectories(plansDir.toPath())
- val templatesDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BluePrintConstants.TOSCA_TEMPLATES_DIR))
+ val templatesDir = File(blueprintDir.absolutePath.plus(File.separator).plus(BlueprintConstants.TOSCA_TEMPLATES_DIR))
Files.createDirectories(templatesDir.toPath())
}
- fun copyBluePrint(sourcePath: String, targetPath: String) {
+ fun copyBlueprint(sourcePath: String, targetPath: String) {
val sourceFile = File(sourcePath)
val targetFile = File(targetPath)
sourceFile.copyRecursively(targetFile, true)
}
- fun deleteBluePrintTypes(basePath: String) {
- val definitionPath = basePath.plus(File.separator).plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR)
+ fun deleteBlueprintTypes(basePath: String) {
+ val definitionPath = basePath.plus(File.separator).plus(BlueprintConstants.TOSCA_DEFINITIONS_DIR)
log.info("deleting definition types under : $definitionPath")
val definitionDir = File(definitionPath)
}
}
- fun writeEnhancedBluePrint(blueprintContext: BluePrintContext) {
+ fun writeEnhancedBlueprint(blueprintContext: BlueprintContext) {
// Write Blueprint Types
- writeBluePrintTypes(blueprintContext)
+ writeBlueprintTypes(blueprintContext)
// Re Populate the Imports
populateDefaultImports(blueprintContext)
// Rewrite the Entry Definition Files
writeEntryDefinitionFile(blueprintContext)
}
- fun writeBluePrintTypes(blueprintContext: BluePrintContext) {
+ fun writeBlueprintTypes(blueprintContext: BlueprintContext) {
val basePath = blueprintContext.rootPath
- val definitionPath = basePath.plus(File.separator).plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR)
+ val definitionPath = basePath.plus(File.separator).plus(BlueprintConstants.TOSCA_DEFINITIONS_DIR)
val definitionDir = File(definitionPath)
check(definitionDir.exists()) {
- throw BluePrintException(
+ throw BlueprintException(
ErrorCode.BLUEPRINT_PATH_MISSING.value,
"couldn't get definition file under " +
"path(${definitionDir.absolutePath})"
}
blueprintContext.serviceTemplate.dataTypes?.let {
- val dataTypesContent = JacksonUtils.getWrappedJson(BluePrintConstants.PATH_DATA_TYPES, it.toSortedMap(), true)
- writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_DATA_TYPES, dataTypesContent)
+ val dataTypesContent = JacksonUtils.getWrappedJson(BlueprintConstants.PATH_DATA_TYPES, it.toSortedMap(), true)
+ writeTypeFile(definitionDir.absolutePath, BlueprintConstants.PATH_DATA_TYPES, dataTypesContent)
}
blueprintContext.serviceTemplate.relationshipTypes?.let {
- val nodeTypesContent = JacksonUtils.getWrappedJson(BluePrintConstants.PATH_RELATIONSHIP_TYPES, it.toSortedMap(), true)
- writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_RELATIONSHIP_TYPES, nodeTypesContent)
+ val nodeTypesContent = JacksonUtils.getWrappedJson(BlueprintConstants.PATH_RELATIONSHIP_TYPES, it.toSortedMap(), true)
+ writeTypeFile(definitionDir.absolutePath, BlueprintConstants.PATH_RELATIONSHIP_TYPES, nodeTypesContent)
}
blueprintContext.serviceTemplate.artifactTypes?.let {
- val artifactTypesContent = JacksonUtils.getWrappedJson(BluePrintConstants.PATH_ARTIFACT_TYPES, it.toSortedMap(), true)
- writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_ARTIFACT_TYPES, artifactTypesContent)
+ val artifactTypesContent = JacksonUtils.getWrappedJson(BlueprintConstants.PATH_ARTIFACT_TYPES, it.toSortedMap(), true)
+ writeTypeFile(definitionDir.absolutePath, BlueprintConstants.PATH_ARTIFACT_TYPES, artifactTypesContent)
}
blueprintContext.serviceTemplate.nodeTypes?.let {
- val nodeTypesContent = JacksonUtils.getWrappedJson(BluePrintConstants.PATH_NODE_TYPES, it.toSortedMap(), true)
- writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_NODE_TYPES, nodeTypesContent)
+ val nodeTypesContent = JacksonUtils.getWrappedJson(BlueprintConstants.PATH_NODE_TYPES, it.toSortedMap(), true)
+ writeTypeFile(definitionDir.absolutePath, BlueprintConstants.PATH_NODE_TYPES, nodeTypesContent)
}
blueprintContext.serviceTemplate.policyTypes?.let {
- val nodeTypesContent = JacksonUtils.getWrappedJson(BluePrintConstants.PATH_POLICY_TYPES, it.toSortedMap(), true)
- writeTypeFile(definitionDir.absolutePath, BluePrintConstants.PATH_POLICY_TYPES, nodeTypesContent)
+ val nodeTypesContent = JacksonUtils.getWrappedJson(BlueprintConstants.PATH_POLICY_TYPES, it.toSortedMap(), true)
+ writeTypeFile(definitionDir.absolutePath, BlueprintConstants.PATH_POLICY_TYPES, nodeTypesContent)
}
}
- private fun populateDefaultImports(blueprintContext: BluePrintContext) {
+ private fun populateDefaultImports(blueprintContext: BlueprintContext) {
// Get the Default Types
val types = arrayListOf(
- BluePrintConstants.PATH_DATA_TYPES, BluePrintConstants.PATH_RELATIONSHIP_TYPES,
- BluePrintConstants.PATH_ARTIFACT_TYPES, BluePrintConstants.PATH_NODE_TYPES,
- BluePrintConstants.PATH_POLICY_TYPES
+ BlueprintConstants.PATH_DATA_TYPES, BlueprintConstants.PATH_RELATIONSHIP_TYPES,
+ BlueprintConstants.PATH_ARTIFACT_TYPES, BlueprintConstants.PATH_NODE_TYPES,
+ BlueprintConstants.PATH_POLICY_TYPES
)
// Clean Type Imports
val imports = mutableListOf<ImportDefinition>()
types.forEach { typeName ->
val import = ImportDefinition()
- import.file = BluePrintConstants.TOSCA_DEFINITIONS_DIR.plus("/$typeName.json")
+ import.file = BlueprintConstants.TOSCA_DEFINITIONS_DIR.plus("/$typeName.json")
imports.add(import)
}
}
/**
- * Re Generate the Blueprint Service Template Definition file based on BluePrint Context.
+ * Re Generate the Blueprint Service Template Definition file based on Blueprint Context.
*/
- private fun writeEntryDefinitionFile(blueprintContext: BluePrintContext) {
+ private fun writeEntryDefinitionFile(blueprintContext: BlueprintContext) {
val absoluteEntryDefinitionFile = blueprintContext.rootPath.plus(File.separator).plus(blueprintContext.entryDefinition)
Files.write(definitionFile.toPath(), content.toByteArray(), StandardOpenOption.CREATE_NEW)
check(definitionFile.exists()) {
- throw BluePrintException(
+ throw BlueprintException(
ErrorCode.BLUEPRINT_WRITING_FAIL.value,
"couldn't write definition file under " +
"path(${definitionFile.absolutePath})"
Files.write(typeFile.toPath(), content.toByteArray(), StandardOpenOption.CREATE_NEW)
check(typeFile.exists()) {
- throw BluePrintException(
+ throw BlueprintException(
ErrorCode.BLUEPRINT_WRITING_FAIL.value,
"couldn't write $type.json file under " +
"path(${typeFile.absolutePath})"
"\nTemplate-Tags: <TAGS>"
}
- fun getBluePrintFile(fileName: String, targetPath: Path): File {
+ fun getBlueprintFile(fileName: String, targetPath: Path): File {
val filePath = targetPath.resolve(fileName).toString()
val file = File(filePath)
check(file.exists()) {
- throw BluePrintException(
+ throw BlueprintException(
ErrorCode.BLUEPRINT_PATH_MISSING.value,
"couldn't get definition file under " +
"path(${file.absolutePath})"
fun getCbaStorageDirectory(path: String): Path {
check(StringUtils.isNotBlank(path)) {
- throw BluePrintException(
+ throw BlueprintException(
ErrorCode.BLUEPRINT_PATH_MISSING.value,
"couldn't get " +
"Blueprint folder under path($path)"
fun compileJarFilePathName(basePath: String, artifactName: String, artifactVersion: String): String {
return normalizedPathName(
- basePath, BluePrintConstants.TOSCA_SCRIPTS_KOTLIN_DIR,
+ basePath, BlueprintConstants.TOSCA_SCRIPTS_KOTLIN_DIR,
compileJarFileName(artifactName, artifactVersion)
)
}
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-object BluePrintIOUtils {
+object BlueprintIOUtils {
suspend fun <T> retry(
times: Int = 1,
import com.fasterxml.jackson.databind.JsonNode
import kotlinx.coroutines.runBlocking
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.ToscaMetaData
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintDefinitions
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintDefinitions
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
import org.onap.ccsdk.cds.controllerblueprints.core.readNBLines
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintScriptsServiceImpl
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintImportService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintScriptsServiceImpl
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintImportService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.slf4j.LoggerFactory
import java.io.File
import java.util.Properties
-class BluePrintMetadataUtils {
+class BlueprintMetadataUtils {
companion object {
private val log = LoggerFactory.getLogger(this::class.toString())
suspend fun toscaMetaData(basePath: String): ToscaMetaData {
- val toscaMetaPath = basePath.plus(BluePrintConstants.PATH_DIVIDER)
- .plus(BluePrintConstants.TOSCA_METADATA_ENTRY_DEFINITION_FILE)
+ val toscaMetaPath = basePath.plus(BlueprintConstants.PATH_DIVIDER)
+ .plus(BlueprintConstants.TOSCA_METADATA_ENTRY_DEFINITION_FILE)
return toscaMetaDataFromMetaFile(toscaMetaPath)
}
suspend fun entryDefinitionFile(basePath: String): String {
- val toscaMetaPath = basePath.plus(BluePrintConstants.PATH_DIVIDER)
- .plus(BluePrintConstants.TOSCA_METADATA_ENTRY_DEFINITION_FILE)
+ val toscaMetaPath = basePath.plus(BlueprintConstants.PATH_DIVIDER)
+ .plus(BlueprintConstants.TOSCA_METADATA_ENTRY_DEFINITION_FILE)
return toscaMetaDataFromMetaFile(toscaMetaPath).entityDefinitions
}
fun bluePrintEnvProperties(basePath: String): Properties {
val blueprintsEnvFilePath = basePath.plus(File.separator)
- .plus(BluePrintConstants.TOSCA_ENVIRONMENTS_DIR)
+ .plus(BlueprintConstants.TOSCA_ENVIRONMENTS_DIR)
return environmentFileProperties(blueprintsEnvFilePath)
}
}
/** Get the default blueprint runtime for [id] and [blueprintBasePath] */
- suspend fun getBluePrintRuntime(id: String, blueprintBasePath: String):
- BluePrintRuntimeService<MutableMap<String, JsonNode>> {
- val bluePrintContext: BluePrintContext = getBluePrintContext(blueprintBasePath)
- return getBluePrintRuntime(id, bluePrintContext)
+ suspend fun getBlueprintRuntime(id: String, blueprintBasePath: String):
+ BlueprintRuntimeService<MutableMap<String, JsonNode>> {
+ val bluePrintContext: BlueprintContext = getBlueprintContext(blueprintBasePath)
+ return getBlueprintRuntime(id, bluePrintContext)
}
/** Get the default blocking blueprint runtime api for [id] and [blueprintBasePath] used in testing */
fun bluePrintRuntime(id: String, blueprintBasePath: String):
- BluePrintRuntimeService<MutableMap<String, JsonNode>> = runBlocking {
- val bluePrintContext: BluePrintContext = getBluePrintContext(blueprintBasePath)
- getBluePrintRuntime(id, bluePrintContext)
+ BlueprintRuntimeService<MutableMap<String, JsonNode>> = runBlocking {
+ val bluePrintContext: BlueprintContext = getBlueprintContext(blueprintBasePath)
+ getBlueprintRuntime(id, bluePrintContext)
}
/** Get the default blueprint runtime from [bluePrintContext] */
- fun getBluePrintRuntime(id: String, bluePrintContext: BluePrintContext):
- BluePrintRuntimeService<MutableMap<String, JsonNode>> {
+ fun getBlueprintRuntime(id: String, bluePrintContext: BlueprintContext):
+ BlueprintRuntimeService<MutableMap<String, JsonNode>> {
checkNotEmpty(bluePrintContext.rootPath) { "blueprint context root path is missing." }
checkNotEmpty(bluePrintContext.entryDefinition) { "blueprint context entry definition is missing." }
val blueprintBasePath = bluePrintContext.rootPath
- val bluePrintRuntimeService = DefaultBluePrintRuntimeService(id, bluePrintContext)
+ val bluePrintRuntimeService = DefaultBlueprintRuntimeService(id, bluePrintContext)
bluePrintRuntimeService.put(
- BluePrintConstants.PROPERTY_BLUEPRINT_BASE_PATH,
+ BlueprintConstants.PROPERTY_BLUEPRINT_BASE_PATH,
blueprintBasePath.asJsonPrimitive()
)
- bluePrintRuntimeService.put(BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID, id.asJsonPrimitive())
+ bluePrintRuntimeService.put(BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID, id.asJsonPrimitive())
return bluePrintRuntimeService
}
/** Get the blueprint runtime for enhancement start for [id] and [blueprintBasePath] */
- suspend fun getBaseEnhancementBluePrintRuntime(id: String, blueprintBasePath: String):
- BluePrintRuntimeService<MutableMap<String, JsonNode>> {
+ suspend fun getBaseEnhancementBlueprintRuntime(id: String, blueprintBasePath: String):
+ BlueprintRuntimeService<MutableMap<String, JsonNode>> {
- val bluePrintContext: BluePrintContext = getBaseEnhancementBluePrintContext(blueprintBasePath)
+ val bluePrintContext: BlueprintContext = getBaseEnhancementBlueprintContext(blueprintBasePath)
- val bluePrintRuntimeService = DefaultBluePrintRuntimeService(id, bluePrintContext)
+ val bluePrintRuntimeService = DefaultBlueprintRuntimeService(id, bluePrintContext)
bluePrintRuntimeService.put(
- BluePrintConstants.PROPERTY_BLUEPRINT_BASE_PATH,
+ BlueprintConstants.PROPERTY_BLUEPRINT_BASE_PATH,
blueprintBasePath.asJsonPrimitive()
)
- bluePrintRuntimeService.put(BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID, id.asJsonPrimitive())
+ bluePrintRuntimeService.put(BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID, id.asJsonPrimitive())
return bluePrintRuntimeService
}
/** Get the default blueprint runtime for enhancement start for [id], [blueprintBasePath] and [executionContext] */
- suspend fun getBluePrintRuntime(
+ suspend fun getBlueprintRuntime(
id: String,
blueprintBasePath: String,
executionContext: MutableMap<String, JsonNode>
):
- BluePrintRuntimeService<MutableMap<String, JsonNode>> {
- val bluePrintContext: BluePrintContext = getBluePrintContext(blueprintBasePath)
- val bluePrintRuntimeService = DefaultBluePrintRuntimeService(id, bluePrintContext)
+ BlueprintRuntimeService<MutableMap<String, JsonNode>> {
+ val bluePrintContext: BlueprintContext = getBlueprintContext(blueprintBasePath)
+ val bluePrintRuntimeService = DefaultBlueprintRuntimeService(id, bluePrintContext)
executionContext.forEach {
bluePrintRuntimeService.put(it.key, it.value)
}
}
/** Get the default blueprint context for [blueprintBasePath]*/
- suspend fun getBluePrintContext(blueprintBasePath: String): BluePrintContext {
+ suspend fun getBlueprintContext(blueprintBasePath: String): BlueprintContext {
val toscaMetaData: ToscaMetaData = toscaMetaData(blueprintBasePath)
// If the EntryDefinition is Kotlin file, compile and get Service Template
val bluePrintContext = when (toscaMetaData.templateType.toUpperCase()) {
- BluePrintConstants.BLUEPRINT_TYPE_KOTLIN_DSL -> readBlueprintKotlinFile(
+ BlueprintConstants.BLUEPRINT_TYPE_KOTLIN_DSL -> readBlueprintKotlinFile(
toscaMetaData,
blueprintBasePath
)
- BluePrintConstants.BLUEPRINT_TYPE_GENERIC_SCRIPT -> readBlueprintGenericScript(
+ BlueprintConstants.BLUEPRINT_TYPE_GENERIC_SCRIPT -> readBlueprintGenericScript(
toscaMetaData,
blueprintBasePath
)
- BluePrintConstants.BLUEPRINT_TYPE_DEFAULT -> readBlueprintFile(
+ BlueprintConstants.BLUEPRINT_TYPE_DEFAULT -> readBlueprintFile(
toscaMetaData.entityDefinitions,
blueprintBasePath
)
else ->
- throw BluePrintException(
+ throw BlueprintException(
"Unknown blueprint type(${toscaMetaData.templateType}), " +
- "It should be any one of these types[${BluePrintConstants.BLUEPRINT_TYPE_KOTLIN_DSL}," +
- "${BluePrintConstants.BLUEPRINT_TYPE_GENERIC_SCRIPT}, " +
- "${BluePrintConstants.BLUEPRINT_TYPE_DEFAULT}]"
+ "It should be any one of these types[${BlueprintConstants.BLUEPRINT_TYPE_KOTLIN_DSL}," +
+ "${BlueprintConstants.BLUEPRINT_TYPE_GENERIC_SCRIPT}, " +
+ "${BlueprintConstants.BLUEPRINT_TYPE_DEFAULT}]"
)
}
// Copy the metadata info
return bluePrintContext
}
- private suspend fun getBaseEnhancementBluePrintContext(blueprintBasePath: String): BluePrintContext {
+ private suspend fun getBaseEnhancementBlueprintContext(blueprintBasePath: String): BlueprintContext {
val toscaMetaData: ToscaMetaData = toscaMetaData(blueprintBasePath)
// Clean Type files
- BluePrintFileUtils.deleteBluePrintTypes(blueprintBasePath)
+ BlueprintFileUtils.deleteBlueprintTypes(blueprintBasePath)
val rootFilePath: String = blueprintBasePath.plus(File.separator).plus(toscaMetaData.entityDefinitions)
val rootServiceTemplate = ServiceTemplateUtils.getServiceTemplate(rootFilePath)
copyMetaInfoToServiceTemplate(toscaMetaData, rootServiceTemplate)
// Clean the Import Definitions
- BluePrintFileUtils.cleanImportTypes(rootServiceTemplate)
+ BlueprintFileUtils.cleanImportTypes(rootServiceTemplate)
- val blueprintContext = BluePrintContext(rootServiceTemplate)
+ val blueprintContext = BlueprintContext(rootServiceTemplate)
blueprintContext.rootPath = blueprintBasePath
blueprintContext.entryDefinition = toscaMetaData.entityDefinitions
return blueprintContext
private fun copyMetaInfoToServiceTemplate(toscaMetaData: ToscaMetaData, serviceTemplate: ServiceTemplate) {
if (serviceTemplate.metadata == null) serviceTemplate.metadata = mutableMapOf()
val metadata = serviceTemplate.metadata!!
- metadata[BluePrintConstants.METADATA_TEMPLATE_AUTHOR] = toscaMetaData.createdBy
- metadata[BluePrintConstants.METADATA_TEMPLATE_NAME] = toscaMetaData.templateName
- metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION] = toscaMetaData.templateVersion
- metadata[BluePrintConstants.METADATA_TEMPLATE_TAGS] = toscaMetaData.templateTags
- metadata[BluePrintConstants.METADATA_TEMPLATE_TYPE] = toscaMetaData.templateType
+ metadata[BlueprintConstants.METADATA_TEMPLATE_AUTHOR] = toscaMetaData.createdBy
+ metadata[BlueprintConstants.METADATA_TEMPLATE_NAME] = toscaMetaData.templateName
+ metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION] = toscaMetaData.templateVersion
+ metadata[BlueprintConstants.METADATA_TEMPLATE_TAGS] = toscaMetaData.templateTags
+ metadata[BlueprintConstants.METADATA_TEMPLATE_TYPE] = toscaMetaData.templateType
}
- private suspend fun readBlueprintFile(entityDefinitions: String, basePath: String): BluePrintContext {
+ private suspend fun readBlueprintFile(entityDefinitions: String, basePath: String): BlueprintContext {
val normalizedBasePath = normalizedPathName(basePath)
val rootFilePath = normalizedPathName(normalizedBasePath, entityDefinitions)
val rootServiceTemplate = ServiceTemplateUtils.getServiceTemplate(rootFilePath)
// Recursively Import Template files
- val schemaImportResolverUtils = BluePrintImportService(rootServiceTemplate, normalizedBasePath)
+ val schemaImportResolverUtils = BlueprintImportService(rootServiceTemplate, normalizedBasePath)
val completeServiceTemplate = schemaImportResolverUtils.getImportResolvedServiceTemplate()
- val blueprintContext = BluePrintContext(completeServiceTemplate)
+ val blueprintContext = BlueprintContext(completeServiceTemplate)
blueprintContext.rootPath = normalizedBasePath
blueprintContext.entryDefinition = entityDefinitions
return blueprintContext
}
/** Reade the Service Template Definitions from the Kotlin file */
- private suspend fun readBlueprintKotlinFile(toscaMetaData: ToscaMetaData, basePath: String): BluePrintContext {
+ private suspend fun readBlueprintKotlinFile(toscaMetaData: ToscaMetaData, basePath: String): BlueprintContext {
val definitionClassName = toscaMetaData.entityDefinitions.removeSuffix(".kt")
val normalizedBasePath = normalizedPathName(basePath)
- val bluePrintScriptsService = BluePrintScriptsServiceImpl()
+ val bluePrintScriptsService = BlueprintScriptsServiceImpl()
val bluePrintDefinitions = bluePrintScriptsService
- .scriptInstance<BluePrintDefinitions>(
+ .scriptInstance<BlueprintDefinitions>(
normalizedBasePath, toscaMetaData.templateName,
toscaMetaData.templateVersion, definitionClassName, false
)
val serviceTemplate = bluePrintDefinitions.serviceTemplate()
// Clean the Default type import Definitions
- BluePrintFileUtils.cleanImportTypes(serviceTemplate)
+ BlueprintFileUtils.cleanImportTypes(serviceTemplate)
- val blueprintContext = BluePrintContext(serviceTemplate)
+ val blueprintContext = BlueprintContext(serviceTemplate)
blueprintContext.rootPath = normalizedBasePath
blueprintContext.entryDefinition = toscaMetaData.entityDefinitions
blueprintContext.otherDefinitions = bluePrintDefinitions.otherDefinitions()
}
/** Reade the Service Template Definitions from the generic script types */
- private fun readBlueprintGenericScript(toscaMetaData: ToscaMetaData, basePath: String): BluePrintContext {
- return BluePrintContext(ServiceTemplate())
+ private fun readBlueprintGenericScript(toscaMetaData: ToscaMetaData, basePath: String): BlueprintContext {
+ return BlueprintContext(ServiceTemplate())
}
}
}
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.slf4j.LoggerFactory
/**
*
* @author Brinda Santh
*/
-object BluePrintRuntimeUtils {
+object BlueprintRuntimeUtils {
private val log = LoggerFactory.getLogger(this::class.toString())
- fun assignInputsFromFile(bluePrintContext: BluePrintContext, fileName: String, context: MutableMap<String, JsonNode>) {
+ fun assignInputsFromFile(bluePrintContext: BlueprintContext, fileName: String, context: MutableMap<String, JsonNode>) {
val jsonNode: JsonNode = JacksonUtils.jsonNodeFromFile(fileName)
return assignInputs(bluePrintContext, jsonNode, context)
}
fun assignInputsFromClassPathFile(
- bluePrintContext: BluePrintContext,
+ bluePrintContext: BlueprintContext,
fileName: String,
context: MutableMap<String,
JsonNode>
return assignInputs(bluePrintContext, jsonNode, context)
}
- fun assignInputsFromContent(bluePrintContext: BluePrintContext, content: String, context: MutableMap<String, JsonNode>) {
+ fun assignInputsFromContent(bluePrintContext: BlueprintContext, content: String, context: MutableMap<String, JsonNode>) {
val jsonNode: JsonNode = JacksonUtils.jsonNode(content)
return assignInputs(bluePrintContext, jsonNode, context)
}
- fun assignInputs(bluePrintContext: BluePrintContext, jsonNode: JsonNode, context: MutableMap<String, JsonNode>) {
+ fun assignInputs(bluePrintContext: BlueprintContext, jsonNode: JsonNode, context: MutableMap<String, JsonNode>) {
log.info("assignInputs from input JSON ({})", jsonNode.toString())
bluePrintContext.inputs()?.forEach { propertyName, _ ->
val valueNode: JsonNode = jsonNode.at("/".plus(propertyName)) ?: NullNode.getInstance()
- val path = BluePrintConstants.PATH_INPUTS.plus(BluePrintConstants.PATH_DIVIDER).plus(propertyName)
+ val path = BlueprintConstants.PATH_INPUTS.plus(BlueprintConstants.PATH_DIVIDER).plus(propertyName)
log.trace("setting input path ({}), values ({})", path, valueNode)
context[path] = valueNode
}
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import java.net.InetAddress
object ClusterUtils {
}
fun applicationName(): String {
- return BluePrintConstants.APP_NAME
+ return BlueprintConstants.APP_NAME
}
fun clusterId(): String {
- return System.getenv(BluePrintConstants.PROPERTY_CLUSTER_ID) ?: "cds-cluster"
+ return System.getenv(BlueprintConstants.PROPERTY_CLUSTER_ID) ?: "cds-cluster"
}
fun clusterNodeId(): String {
- return System.getenv(BluePrintConstants.PROPERTY_CLUSTER_NODE_ID) ?: "cds-controller-0"
+ return System.getenv(BlueprintConstants.PROPERTY_CLUSTER_NODE_ID) ?: "cds-controller-0"
}
fun clusterNodeAddress(): String {
- return System.getenv(BluePrintConstants.PROPERTY_CLUSTER_NODE_ADDRESS)
+ return System.getenv(BlueprintConstants.PROPERTY_CLUSTER_NODE_ADDRESS)
?: clusterNodeId()
}
}
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import java.text.SimpleDateFormat
import java.time.LocalDateTime
import java.time.ZoneId
fun currentTimestamp(): String {
val localDateTime = LocalDateTime.now(ZoneId.systemDefault())
- val formatter = DateTimeFormatter.ofPattern(BluePrintConstants.DATE_TIME_PATTERN)
+ val formatter = DateTimeFormatter.ofPattern(BlueprintConstants.DATE_TIME_PATTERN)
return formatter.format(localDateTime)
}
/** Parse string date in CDS string format */
fun String.toControllerDate(): Date {
- val formatter = SimpleDateFormat(BluePrintConstants.DATE_TIME_PATTERN)
+ val formatter = SimpleDateFormat(BlueprintConstants.DATE_TIME_PATTERN)
return formatter.parse(this)
}
/** Return date to CDS string format */
fun Date.currentTimestamp(): String {
- val formatter = SimpleDateFormat(BluePrintConstants.DATE_TIME_PATTERN)
+ val formatter = SimpleDateFormat(BlueprintConstants.DATE_TIME_PATTERN)
return formatter.format(this)
}
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import org.apache.commons.io.IOUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.readNBText
import java.io.File
try {
normalizedFile(fileName).readNBText()
} catch (e: Exception) {
- throw BluePrintException("couldn't get file ($fileName) content : ${e.message}")
+ throw BlueprintException("couldn't get file ($fileName) content : ${e.message}")
}
}
fun <T> getInstanceFromMap(properties: MutableMap<String, JsonNode>, classType: Class<T>): T {
return readValue(getJson(properties), classType)
- ?: throw BluePrintProcessorException("failed to transform content ($properties) to type ($classType)")
+ ?: throw BlueprintProcessorException("failed to transform content ($properties) to type ($classType)")
}
fun checkJsonNodeValueOfType(type: String, jsonNode: JsonNode): Boolean {
- if (BluePrintTypes.validPrimitiveTypes().contains(type.toLowerCase())) {
+ if (BlueprintTypes.validPrimitiveTypes().contains(type.toLowerCase())) {
return checkJsonNodeValueOfPrimitiveType(type, jsonNode)
- } else if (BluePrintTypes.validCollectionTypes().contains(type)) {
+ } else if (BlueprintTypes.validCollectionTypes().contains(type)) {
return checkJsonNodeValueOfCollectionType(type, jsonNode)
}
return false
fun checkIfPrimitiveType(primitiveType: String): Boolean {
return when (primitiveType.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_STRING -> true
- BluePrintConstants.DATA_TYPE_BOOLEAN -> true
- BluePrintConstants.DATA_TYPE_INTEGER -> true
- BluePrintConstants.DATA_TYPE_FLOAT -> true
- BluePrintConstants.DATA_TYPE_DOUBLE -> true
- BluePrintConstants.DATA_TYPE_TIMESTAMP -> true
+ BlueprintConstants.DATA_TYPE_STRING -> true
+ BlueprintConstants.DATA_TYPE_BOOLEAN -> true
+ BlueprintConstants.DATA_TYPE_INTEGER -> true
+ BlueprintConstants.DATA_TYPE_FLOAT -> true
+ BlueprintConstants.DATA_TYPE_DOUBLE -> true
+ BlueprintConstants.DATA_TYPE_TIMESTAMP -> true
else -> false
}
}
fun checkJsonNodeValueOfPrimitiveType(primitiveType: String, jsonNode: JsonNode): Boolean {
return when (primitiveType.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_STRING -> jsonNode.isTextual
- BluePrintConstants.DATA_TYPE_BOOLEAN -> jsonNode.isBoolean
- BluePrintConstants.DATA_TYPE_INTEGER -> jsonNode.isInt
- BluePrintConstants.DATA_TYPE_FLOAT -> jsonNode.isDouble
- BluePrintConstants.DATA_TYPE_DOUBLE -> jsonNode.isDouble
- BluePrintConstants.DATA_TYPE_TIMESTAMP -> jsonNode.isTextual
+ BlueprintConstants.DATA_TYPE_STRING -> jsonNode.isTextual
+ BlueprintConstants.DATA_TYPE_BOOLEAN -> jsonNode.isBoolean
+ BlueprintConstants.DATA_TYPE_INTEGER -> jsonNode.isInt
+ BlueprintConstants.DATA_TYPE_FLOAT -> jsonNode.isDouble
+ BlueprintConstants.DATA_TYPE_DOUBLE -> jsonNode.isDouble
+ BlueprintConstants.DATA_TYPE_TIMESTAMP -> jsonNode.isTextual
else -> false
}
}
fun checkJsonNodeValueOfCollectionType(type: String, jsonNode: JsonNode): Boolean {
return when (type.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_LIST -> jsonNode.isArray
+ BlueprintConstants.DATA_TYPE_LIST -> jsonNode.isArray
else -> false
}
}
fun getValue(value: Any, type: String): Any {
return when (type.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_BOOLEAN -> (value as BooleanNode).booleanValue()
- BluePrintConstants.DATA_TYPE_INTEGER -> (value as IntNode).intValue()
- BluePrintConstants.DATA_TYPE_FLOAT -> (value as FloatNode).floatValue()
- BluePrintConstants.DATA_TYPE_DOUBLE -> (value as DoubleNode).doubleValue()
- BluePrintConstants.DATA_TYPE_STRING -> (value as TextNode).textValue()
+ BlueprintConstants.DATA_TYPE_BOOLEAN -> (value as BooleanNode).booleanValue()
+ BlueprintConstants.DATA_TYPE_INTEGER -> (value as IntNode).intValue()
+ BlueprintConstants.DATA_TYPE_FLOAT -> (value as FloatNode).floatValue()
+ BlueprintConstants.DATA_TYPE_DOUBLE -> (value as DoubleNode).doubleValue()
+ BlueprintConstants.DATA_TYPE_STRING -> (value as TextNode).textValue()
else -> (value as JsonNode)
}
}
fun populatePrimitiveValues(key: String, value: JsonNode, primitiveType: String, objectNode: ObjectNode) {
when (primitiveType.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_BOOLEAN,
- BluePrintConstants.DATA_TYPE_INTEGER,
- BluePrintConstants.DATA_TYPE_FLOAT,
- BluePrintConstants.DATA_TYPE_DOUBLE,
- BluePrintConstants.DATA_TYPE_TIMESTAMP,
- BluePrintConstants.DATA_TYPE_STRING,
- BluePrintConstants.DATA_TYPE_NULL ->
+ BlueprintConstants.DATA_TYPE_BOOLEAN,
+ BlueprintConstants.DATA_TYPE_INTEGER,
+ BlueprintConstants.DATA_TYPE_FLOAT,
+ BlueprintConstants.DATA_TYPE_DOUBLE,
+ BlueprintConstants.DATA_TYPE_TIMESTAMP,
+ BlueprintConstants.DATA_TYPE_STRING,
+ BlueprintConstants.DATA_TYPE_NULL ->
objectNode.set(key, value)
- else -> throw BluePrintException("populatePrimitiveValues expected only primitive values! Received: ($value)")
+ else -> throw BlueprintException("populatePrimitiveValues expected only primitive values! Received: ($value)")
}
}
fun populatePrimitiveValues(value: JsonNode, primitiveType: String, arrayNode: ArrayNode) {
when (primitiveType.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_BOOLEAN,
- BluePrintConstants.DATA_TYPE_INTEGER,
- BluePrintConstants.DATA_TYPE_FLOAT,
- BluePrintConstants.DATA_TYPE_DOUBLE,
- BluePrintConstants.DATA_TYPE_TIMESTAMP,
- BluePrintConstants.DATA_TYPE_STRING,
- BluePrintConstants.DATA_TYPE_NULL ->
+ BlueprintConstants.DATA_TYPE_BOOLEAN,
+ BlueprintConstants.DATA_TYPE_INTEGER,
+ BlueprintConstants.DATA_TYPE_FLOAT,
+ BlueprintConstants.DATA_TYPE_DOUBLE,
+ BlueprintConstants.DATA_TYPE_TIMESTAMP,
+ BlueprintConstants.DATA_TYPE_STRING,
+ BlueprintConstants.DATA_TYPE_NULL ->
arrayNode.add(value)
- else -> throw BluePrintException("populatePrimitiveValues expected only primitive values! Received: ($value)")
+ else -> throw BlueprintException("populatePrimitiveValues expected only primitive values! Received: ($value)")
}
}
fun populatePrimitiveDefaultValues(key: String, primitiveType: String, objectNode: ObjectNode) {
val defaultValue = getDefaultValueOfPrimitiveAsJsonNode(primitiveType)
- ?: throw BluePrintException("populatePrimitiveDefaultValues expected only primitive values! Received type ($primitiveType)")
+ ?: throw BlueprintException("populatePrimitiveDefaultValues expected only primitive values! Received type ($primitiveType)")
objectNode.set<JsonNode>(key, defaultValue)
}
fun populatePrimitiveDefaultValuesForArrayNode(primitiveType: String, arrayNode: ArrayNode) {
val defaultValue = getDefaultValueOfPrimitiveAsJsonNode(primitiveType)
- ?: throw BluePrintException("populatePrimitiveDefaultValuesForArrayNode expected only primitive values! Received type ($primitiveType)")
+ ?: throw BlueprintException("populatePrimitiveDefaultValuesForArrayNode expected only primitive values! Received type ($primitiveType)")
arrayNode.add(defaultValue)
}
private fun getDefaultValueOfPrimitiveAsJsonNode(primitiveType: String): JsonNode? {
return when (primitiveType.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_BOOLEAN -> BooleanNode.valueOf(false)
- BluePrintConstants.DATA_TYPE_INTEGER -> IntNode.valueOf(0)
- BluePrintConstants.DATA_TYPE_FLOAT -> FloatNode.valueOf(0.0f)
- BluePrintConstants.DATA_TYPE_DOUBLE -> DoubleNode.valueOf(0.0)
- BluePrintConstants.DATA_TYPE_STRING -> MissingNode.getInstance()
+ BlueprintConstants.DATA_TYPE_BOOLEAN -> BooleanNode.valueOf(false)
+ BlueprintConstants.DATA_TYPE_INTEGER -> IntNode.valueOf(0)
+ BlueprintConstants.DATA_TYPE_FLOAT -> FloatNode.valueOf(0.0f)
+ BlueprintConstants.DATA_TYPE_DOUBLE -> DoubleNode.valueOf(0.0)
+ BlueprintConstants.DATA_TYPE_STRING -> MissingNode.getInstance()
else -> null
}
}
fun populateJsonNodeValues(key: String, nodeValue: JsonNode?, type: String, objectNode: ObjectNode) {
if (nodeValue == null || nodeValue is NullNode) {
objectNode.set<JsonNode>(key, nodeValue)
- } else if (BluePrintTypes.validPrimitiveTypes().contains(type)) {
+ } else if (BlueprintTypes.validPrimitiveTypes().contains(type)) {
populatePrimitiveValues(key, nodeValue, type, objectNode)
} else {
objectNode.set<JsonNode>(key, nodeValue)
fun convertPrimitiveResourceValue(type: String, value: String): JsonNode {
return when (type.toLowerCase()) {
- BluePrintConstants.DATA_TYPE_BOOLEAN -> jsonNodeFromObject(value.toBoolean())
- BluePrintConstants.DATA_TYPE_INTEGER -> jsonNodeFromObject(value.toInt())
- BluePrintConstants.DATA_TYPE_FLOAT -> jsonNodeFromObject(value.toFloat())
- BluePrintConstants.DATA_TYPE_DOUBLE -> jsonNodeFromObject(value.toDouble())
- BluePrintConstants.DATA_TYPE_STRING -> jsonNodeFromObject(value)
+ BlueprintConstants.DATA_TYPE_BOOLEAN -> jsonNodeFromObject(value.toBoolean())
+ BlueprintConstants.DATA_TYPE_INTEGER -> jsonNodeFromObject(value.toInt())
+ BlueprintConstants.DATA_TYPE_FLOAT -> jsonNodeFromObject(value.toFloat())
+ BlueprintConstants.DATA_TYPE_DOUBLE -> jsonNodeFromObject(value.toDouble())
+ BlueprintConstants.DATA_TYPE_STRING -> jsonNodeFromObject(value)
else -> getJsonNode(value)
}
}
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.LOG_PROTECT
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.LOG_PROTECT
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
class PropertyDefinitionUtils {
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.isNotEmpty
import org.slf4j.LoggerFactory
import java.io.File
// FIXME("Convert into reactive")
return JacksonUtils.getContent(resolvedFileName)
} catch (e: Exception) {
- throw BluePrintException(e, "failed to file (%s), basePath (%s) ", filename, basePath)
+ throw BlueprintException(e, "failed to file (%s), basePath (%s) ", filename, basePath)
}
}
}
package org.onap.ccsdk.cds.controllerblueprints.core.utils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.data.EdgeLabel
import org.onap.ccsdk.cds.controllerblueprints.core.data.Graph
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
}
}
graph.startNodes().forEach { rootNode ->
- graph.addEdge(BluePrintConstants.GRAPH_START_NODE_NAME, rootNode.id, EdgeLabel.SUCCESS)
+ graph.addEdge(BlueprintConstants.GRAPH_START_NODE_NAME, rootNode.id, EdgeLabel.SUCCESS)
}
graph.endNodes().forEach { endNode ->
- graph.addEdge(endNode.id, BluePrintConstants.GRAPH_END_NODE_NAME, EdgeLabel.SUCCESS)
+ graph.addEdge(endNode.id, BlueprintConstants.GRAPH_END_NODE_NAME, EdgeLabel.SUCCESS)
}
return graph
}
import kotlin.test.assertEquals
import kotlin.test.assertTrue
-class BluePrintErrorTest {
+class BlueprintErrorTest {
@Test
- fun testBluePrintErrorIsCreatedWithemptyList() {
- val bluePrintError = BluePrintError()
+ fun testBlueprintErrorIsCreatedWithemptyList() {
+ val bluePrintError = BlueprintError()
assertTrue(bluePrintError.errors.isEmpty())
}
@Test
fun testAddErrorWith3Params() {
- val bluePrintError = BluePrintError()
+ val bluePrintError = BlueprintError()
bluePrintError.addError("type", "name", "error")
@Test
fun testAddErrorWith1Params() {
- val bluePrintError = BluePrintError()
+ val bluePrintError = BlueprintError()
bluePrintError.addError("error")
val returnValueBool: JsonNode = false.asJsonType()
assertFalse(returnValueBool.asBoolean())
- val returnValue: JsonNode = BluePrintError().asJsonType()
+ val returnValue: JsonNode = BlueprintError().asJsonType()
assertEquals(JsonNodeType.OBJECT, returnValue.getNodeType())
}
@Test
fun testMapAsObjectNode() {
- val returnValue: ObjectNode = hashMapOf("test" to BluePrintError()).asObjectNode()
+ val returnValue: ObjectNode = hashMapOf("test" to BlueprintError()).asObjectNode()
assertNotNull(returnValue.get("test"))
}
assertNull(returnValueString)
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testCastValue() {
val initMap: Map<String, Double> = hashMapOf("test" to 1.1)
val returnValue = initMap.castValue("test", Number::class)
assertTrue("[{\"key\": \"value\"},{\"key\": \"value\"}]".asJsonType().isComplexType())
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testRootFieldsToMap() {
1.asJsonType().rootFieldsToMap()
}
assertEquals(3, mutMap["hello"]?.asInt())
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testMapGetAsString() {
val initMap = hashMapOf("test" to "hello".asJsonType())
initMap.getAsString("test2")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testMapGetAsBoolean() {
val initMap = hashMapOf("test" to true.asJsonType())
initMap.getAsBoolean("test2")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testMapGetAsInt() {
val initMap = hashMapOf("test" to 1.asJsonType())
initMap.getAsInt("test2")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testCheckEquals() {
assertTrue(checkEquals("hello", "hello", { -> "error" }))
@Test
fun testContextCanBePassedBetweenCoroutines() {
- MDC.put(BluePrintConstants.ONAP_REQUEST_ID, "12345")
+ MDC.put(BlueprintConstants.ONAP_REQUEST_ID, "12345")
runBlocking {
GlobalScope.launch {
- assertEquals(null, MDC.get(BluePrintConstants.ONAP_REQUEST_ID))
+ assertEquals(null, MDC.get(BlueprintConstants.ONAP_REQUEST_ID))
}
launch(MDCContext()) {
assertEquals(
- "12345", MDC.get(BluePrintConstants.ONAP_REQUEST_ID),
+ "12345", MDC.get(BlueprintConstants.ONAP_REQUEST_ID),
"couldn't get request id"
)
package org.onap.ccsdk.cds.controllerblueprints.core.annotations
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.asBluePrintsDataTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.asBlueprintsDataTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asPropertyDefinitionMap
import kotlin.test.Test
import kotlin.test.assertNotNull
-class BluePrintsAnnotationsTest {
+class BlueprintsAnnotationsTest {
@Test
- fun testBluePrintWorkflowData() {
- val wfInput = TestBluePrintsWorkflowInput::class.asPropertyDefinitionMap()
+ fun testBlueprintWorkflowData() {
+ val wfInput = TestBlueprintsWorkflowInput::class.asPropertyDefinitionMap()
// println(wfInput.asJsonString(true))
assertNotNull(wfInput, "failed to generate wfInput property map")
- val wfOutput = TestBluePrintsWorkflowOutput::class.asPropertyDefinitionMap()
+ val wfOutput = TestBlueprintsWorkflowOutput::class.asPropertyDefinitionMap()
// println(wfOutput.asJsonString(true))
assertNotNull(wfInput, "failed to generate wfOutput property map")
}
@Test
- fun testBluePrintDataType() {
- val dataTypes = TestBluePrintsDataType::class.asBluePrintsDataTypes()
+ fun testBlueprintDataType() {
+ val dataTypes = TestBlueprintsDataType::class.asBlueprintsDataTypes()
// println(dataTypes.asJsonString(true))
assertNotNull(dataTypes, "failed to generate dataTypes definition")
}
}
-@BluePrintsDataType(
+@BlueprintsDataType(
name = "dt-test-datatype", description = "I am test",
version = "1.0.0", derivedFrom = "tosca.datatypes.root"
)
-data class TestBluePrintsDataType(
- @BluePrintsProperty(description = "this stringData")
+data class TestBlueprintsDataType(
+ @BlueprintsProperty(description = "this stringData")
var stringData: String,
- @BluePrintsProperty(description = "this stringDataWithValue")
+ @BlueprintsProperty(description = "this stringDataWithValue")
@PropertyDefaultValue(value = "USA")
val stringDataWithValue: String,
- @BluePrintsProperty(description = "this intDataWithValue")
+ @BlueprintsProperty(description = "this intDataWithValue")
@PropertyDefaultValue(value = "30")
val intDataWithValue: Int,
- @BluePrintsProperty(description = "this booleanDataWithValue")
+ @BlueprintsProperty(description = "this booleanDataWithValue")
@PropertyDefaultValue(value = "true")
val booleanDataWithValue: Boolean,
- @BluePrintsProperty(description = "this anyData")
+ @BlueprintsProperty(description = "this anyData")
val anyData: Any,
- @BluePrintsProperty(description = "this jsonDataWithValue")
+ @BlueprintsProperty(description = "this jsonDataWithValue")
@PropertyDefaultValue(value = """{"data" : "1234"}""")
val jsonDataWithValue: JsonNode?,
- @BluePrintsProperty(description = "listData")
+ @BlueprintsProperty(description = "listData")
val listData: MutableList<String>,
- @BluePrintsProperty(description = "this mapData")
+ @BlueprintsProperty(description = "this mapData")
val mapData: MutableMap<String, String> = hashMapOf(),
- @BluePrintsProperty(description = "this complexData")
- val complexData: TestBluePrintsChildDataType?,
- @BluePrintsProperty(description = "this complexDataList")
- val complexDataList: MutableList<TestBluePrintsChildDataType>
+ @BlueprintsProperty(description = "this complexData")
+ val complexData: TestBlueprintsChildDataType?,
+ @BlueprintsProperty(description = "this complexDataList")
+ val complexDataList: MutableList<TestBlueprintsChildDataType>
)
-data class TestBluePrintsChildDataType(val name: String)
+data class TestBlueprintsChildDataType(val name: String)
-@BluePrintsWorkflowInput
-data class TestBluePrintsWorkflowInput(
- @BluePrintsProperty(description = "this sample name")
+@BlueprintsWorkflowInput
+data class TestBlueprintsWorkflowInput(
+ @BlueprintsProperty(description = "this sample name")
@PropertyDefaultValue(value = "Brinda")
var name: String,
- @BluePrintsProperty(description = "this sample name")
+ @BlueprintsProperty(description = "this sample name")
val place: String
)
-@BluePrintsWorkflowOutput
-data class TestBluePrintsWorkflowOutput(
- @BluePrintsProperty(description = "this is dslExpression")
+@BlueprintsWorkflowOutput
+data class TestBlueprintsWorkflowOutput(
+ @BlueprintsProperty(description = "this is dslExpression")
@DSLExpression("field1")
var dslExpression: String,
- @BluePrintsProperty(description = "this is withNodeAttributeExpression")
+ @BlueprintsProperty(description = "this is withNodeAttributeExpression")
@AttributeExpression(modelableEntityName = "sample-node", attributeName = "response-data")
var withNodeAttributeExpression: String,
- @BluePrintsProperty(description = "this is withNodeAttributeExpressionSubAttribute")
+ @BlueprintsProperty(description = "this is withNodeAttributeExpressionSubAttribute")
@AttributeExpression(
modelableEntityName = "sample-node", attributeName = "response-data",
subAttributeName = ".\$field1"
)
var withNodeAttributeExpressionSubAttribute: String,
- @BluePrintsProperty(description = "this is withAttributeExpressionSubAttribute")
+ @BlueprintsProperty(description = "this is withAttributeExpressionSubAttribute")
@AttributeExpression(attributeName = "response-data", subAttributeName = ".\$field1")
var withAttributeExpressionSubAttribute: String,
- @BluePrintsProperty(description = "this is withAttributeExpression")
+ @BlueprintsProperty(description = "this is withAttributeExpression")
@AttributeExpression(attributeName = "response-data")
var withAttributeExpression: String,
- @BluePrintsProperty(description = "this is withAArtifactExpression")
+ @BlueprintsProperty(description = "this is withAArtifactExpression")
@ArtifactExpression(modelableEntityName = "test-node", artifactName = "content-template")
var withAArtifactExpression: String,
- @BluePrintsProperty(description = "this status")
+ @BlueprintsProperty(description = "this status")
val status: String = "success"
)
import com.fasterxml.jackson.databind.JsonNode
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.jsonAsJsonType
import kotlin.test.assertNotNull
-class BluePrintDSLTest {
+class BlueprintDSLTest {
@Test
fun testOperationDSLWorkflow() {
"brindasanth@onap.com", "sample, blueprints"
) {
- artifactType(BluePrintTypes.artifactTypeTemplateVelocity())
+ artifactType(BlueprintTypes.artifactTypeTemplateVelocity())
// For New Component Definition
component(
assertNotNull(blueprint.workflows, "failed to get workflows")
// println(blueprint.asJsonString(true))
- val serviceTemplateGenerator = BluePrintServiceTemplateGenerator(blueprint)
+ val serviceTemplateGenerator = BlueprintServiceTemplateGenerator(blueprint)
val serviceTemplate = serviceTemplateGenerator.serviceTemplate()
assertNotNull(serviceTemplate.topologyTemplate, "failed to get service topology template")
// println(serviceTemplate.asJsonString(true))
@Test
fun testNodeTemplateOperationTypes() {
- val testNodeTemplateInstance = BluePrintTypes.nodeTemplateComponentTestExecutor(
+ val testNodeTemplateInstance = BlueprintTypes.nodeTemplateComponentTestExecutor(
id = "test-node-template",
description = ""
) {
}
}
-fun BluePrintTypes.nodeTemplateComponentTestExecutor(
+fun BlueprintTypes.nodeTemplateComponentTestExecutor(
id: String,
description: String,
block: TestNodeTemplateOperationImplBuilder.() -> Unit
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintDefinitions
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintDefinitions
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintFunctionNode
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
import kotlin.script.experimental.jvm.util.classpathFromClass
import kotlin.script.experimental.jvm.util.classpathFromClasspathProperty
import kotlin.test.assertNotNull
-class BluePrintScriptsServiceImplTest {
+class BlueprintScriptsServiceImplTest {
private fun viewClassPathInfo() {
println(" *********** classpathFromClass *********** ")
classpathFromClass(
- BluePrintScriptsServiceImplTest::class.java.classLoader,
- BluePrintScriptsServiceImplTest::class
+ BlueprintScriptsServiceImplTest::class.java.classLoader,
+ BlueprintScriptsServiceImplTest::class
)!!
.forEach(::println)
println(" *********** classpathFromClassloader *********** ")
- classpathFromClassloader(BluePrintScriptsServiceImplTest::class.java.classLoader)!!
+ classpathFromClassloader(BlueprintScriptsServiceImplTest::class.java.classLoader)!!
.forEach(::println)
println(" *********** classpathFromClasspathProperty *********** ")
fun testCachedService() {
runBlocking {
- val bluePrintScriptsService = BluePrintScriptsServiceImpl()
+ val bluePrintScriptsService = BlueprintScriptsServiceImpl()
val basePath = normalizedPathName("src/test/resources/compile")
/** Load the Definitions */
val bluePrintDefinitions = bluePrintScriptsService
- .scriptInstance<BluePrintDefinitions>(
+ .scriptInstance<BlueprintDefinitions>(
basePath,
"cba.scripts.ActivateBlueprintDefinitions", true
)
import com.fasterxml.jackson.databind.ObjectMapper
import kotlinx.coroutines.runBlocking
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.TestConstants
import org.onap.ccsdk.cds.controllerblueprints.core.data.Activity
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.Step
import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
import kotlin.test.assertEquals
*
* @author Brinda Santh
*/
-class BluePrintContextTest {
+class BlueprintContextTest {
private val log = LoggerFactory.getLogger(this::class.toString())
val blueprintBasePath = TestConstants.PATH_TEST_BLUEPRINTS_BASECONFIG
@Test
- fun testBluePrintContextCreation() {
+ fun testBlueprintContextCreation() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(blueprintBasePath)
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(blueprintBasePath)
assertNotNull(bluePrintContext, "Failed to populate Blueprint context")
}
}
@Test
fun testChainedProperty() {
runBlocking {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(blueprintBasePath)
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(blueprintBasePath)
val nodeType = bluePrintContext.nodeTypeChained("component-resource-resolution")
assertNotNull(nodeType, "Failed to get chained node type")
log.trace("Properties {}", JacksonUtils.getJson(nodeType, true))
fun testImports() {
val serviceTemplate = ServiceTemplate()
serviceTemplate.imports = mutableListOf()
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.imports()!!.isEmpty())
fun testDataTypes() {
val serviceTemplate = ServiceTemplate()
serviceTemplate.dataTypes = mutableMapOf()
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.dataTypes()!!.isEmpty())
topologyTemplate.inputs = mutableMapOf()
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.inputs()!!.isEmpty())
}
@Test
- fun testBluePrintJson() {
+ fun testBlueprintJson() {
val serviceTemplate = ServiceTemplate()
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("{\"tosca_definitions_version\":\"controller_blueprint_1_0_0\"}", bluePrintContext.blueprintJson())
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testName() {
val serviceTemplate = ServiceTemplate()
- serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_NAME to "hello")
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ serviceTemplate.metadata = mutableMapOf(BlueprintConstants.METADATA_TEMPLATE_NAME to "hello")
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("hello", bluePrintContext.name())
serviceTemplate.metadata = mutableMapOf()
- val bluePrintContext2 = BluePrintContext(serviceTemplate)
+ val bluePrintContext2 = BlueprintContext(serviceTemplate)
bluePrintContext2.name()
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testVersion() {
val serviceTemplate = ServiceTemplate()
- serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_VERSION to "hello")
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ serviceTemplate.metadata = mutableMapOf(BlueprintConstants.METADATA_TEMPLATE_VERSION to "hello")
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("hello", bluePrintContext.version())
serviceTemplate.metadata = mutableMapOf()
- val bluePrintContext2 = BluePrintContext(serviceTemplate)
+ val bluePrintContext2 = BlueprintContext(serviceTemplate)
bluePrintContext2.version()
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testAuthor() {
val serviceTemplate = ServiceTemplate()
- serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_AUTHOR to "hello")
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ serviceTemplate.metadata = mutableMapOf(BlueprintConstants.METADATA_TEMPLATE_AUTHOR to "hello")
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("hello", bluePrintContext.author())
serviceTemplate.metadata = mutableMapOf()
- val bluePrintContext2 = BluePrintContext(serviceTemplate)
+ val bluePrintContext2 = BlueprintContext(serviceTemplate)
bluePrintContext2.author()
}
topologyTemplate.workflows = mutableMapOf()
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.workflows()!!.isEmpty())
assertNull(bluePrintContext.workflows())
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testWorkFlowsByName() {
val topologyTemplate = TopologyTemplate()
topologyTemplate.workflows = mutableMapOf("workflow" to Workflow())
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.workflowByName("workflow"))
topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.workflowInputs("workflow")!!.isEmpty())
assertNull(bluePrintContext.workflowInputs("workflow"))
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testWorkflowStepByName() {
val topologyTemplate = TopologyTemplate()
val workflow = Workflow()
topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.workflowStepByName("workflow", "step"))
bluePrintContext.workflowStepByName("workflow", "")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testWorkflowStepNodeTemplate() {
val topologyTemplate = TopologyTemplate()
val workflow = Workflow()
topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("hello", bluePrintContext.workflowStepNodeTemplate("workflow", "step"))
bluePrintContext.workflowStepNodeTemplate("workflow", "")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testWorkflowFirstStepNodeTemplate() {
val topologyTemplate = TopologyTemplate()
val workflow = Workflow()
topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("hello", bluePrintContext.workflowFirstStepNodeTemplate("workflow"))
bluePrintContext.workflowFirstStepNodeTemplate("workflow")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testWorkflowStepFirstCallOperation() {
val topologyTemplate = TopologyTemplate()
val workflow = Workflow()
topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
val serviceTemplate = ServiceTemplate()
serviceTemplate.topologyTemplate = topologyTemplate
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("hello", bluePrintContext.workflowStepFirstCallOperation("workflow", "step"))
fun testDatatypeByName() {
val serviceTemplate = ServiceTemplate()
serviceTemplate.dataTypes = mutableMapOf("data" to DataType())
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.dataTypeByName("data"))
assertNull(bluePrintContext.dataTypeByName(""))
fun testArtifactTypes() {
val serviceTemplate = ServiceTemplate()
serviceTemplate.artifactTypes = mutableMapOf()
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.artifactTypes()!!.isEmpty())
fun testPolicyTypes() {
val serviceTemplate = ServiceTemplate()
serviceTemplate.policyTypes = mutableMapOf()
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.policyTypes()!!.isEmpty())
assertNull(bluePrintContext.policyTypes())
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testPolicyTypeByName() {
val serviceTemplate = ServiceTemplate()
serviceTemplate.policyTypes = mutableMapOf("policy" to PolicyType())
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.policyTypeByName("policy"))
val policyType2 = PolicyType()
policyType2.derivedFrom = "hello"
serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals(1, bluePrintContext.policyTypesDerivedFrom("hi")!!.size)
val policyType2 = PolicyType()
policyType2.targets = mutableListOf()
serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals(1, bluePrintContext.policyTypesTarget("hi")!!.size)
policyType2.targets = mutableListOf()
policyType2.derivedFrom = "hi"
serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals(1, bluePrintContext.policyTypesTargetNDerivedFrom("hi", "hi")!!.size)
val nodeType2 = NodeType()
nodeType2.derivedFrom = "hiii"
serviceTemplate.nodeTypes = mutableMapOf("node" to nodeType, "node2" to nodeType2)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals(1, bluePrintContext.nodeTypeDerivedFrom("hi")!!.size)
assertNull(bluePrintContext.nodeTypeDerivedFrom("hi"))
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testInterfaceNameForNodeType() {
val serviceTemplate = ServiceTemplate()
val nodeType = NodeType()
nodeType.interfaces = mutableMapOf("hello" to InterfaceDefinition(), "hi" to InterfaceDefinition())
serviceTemplate.nodeTypes = mutableMapOf("node" to nodeType)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("hello", bluePrintContext.interfaceNameForNodeType("node"))
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates =
mutableMapOf("node" to nodeTemplate, "node2" to nodeTemplate2)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals(1, bluePrintContext.nodeTemplateForNodeType("hello")!!.size)
nodeTemplate.properties = mutableMapOf("prop" to ObjectMapper().createObjectNode())
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateProperty("node", "prop"))
nodeTemplate.artifacts = mutableMapOf()
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertTrue(bluePrintContext.nodeTemplateArtifacts("node")!!.isEmpty())
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateArtifact() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.artifacts = mutableMapOf("art" to ArtifactDefinition())
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateArtifact("node", "art"))
bluePrintContext.nodeTemplateArtifact("node", "")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateArtifactForArtifactType() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.artifacts = mutableMapOf("art" to artifactDefinition, "art2" to artifactDefinition2)
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateArtifactForArtifactType("node", "type"))
bluePrintContext.nodeTemplateArtifactForArtifactType("", "")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateFirstInterface() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.interfaces = mutableMapOf("interface" to InterfaceAssignment(), "interf" to InterfaceAssignment())
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateFirstInterface("node"))
bluePrintContext.nodeTemplateFirstInterface("node")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateFirstInterfaceName() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.interfaces = mutableMapOf("interface" to InterfaceAssignment(), "interf" to InterfaceAssignment())
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("interface", bluePrintContext.nodeTemplateFirstInterfaceName("node"))
bluePrintContext.nodeTemplateFirstInterfaceName("node")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateFirstInterfaceFirstOperationName() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.interfaces = mutableMapOf("intf" to interfaceAssignment)
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertEquals("op", bluePrintContext.nodeTemplateFirstInterfaceFirstOperationName("node"))
bluePrintContext.nodeTemplateFirstInterfaceFirstOperationName("node")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateCapability() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.capabilities = mutableMapOf("cap" to CapabilityAssignment())
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateCapability("node", "cap"))
bluePrintContext.nodeTemplateCapability("node", "")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateRequirement() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.requirements = mutableMapOf("req" to RequirementAssignment())
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateRequirement("node", "req"))
bluePrintContext.nodeTemplateRequirement("node", "")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testNodeTemplateRequirementNode() {
val serviceTemplate = ServiceTemplate()
val nodeTemplate = NodeTemplate()
nodeTemplate.requirements = mutableMapOf("req" to requirementAssignment)
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateRequirementNode("node", "req"))
nodeTemplate.capabilities = mutableMapOf("cap" to capabilityAssignment)
serviceTemplate.topologyTemplate = TopologyTemplate()
serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
assertNotNull(bluePrintContext.nodeTemplateCapabilityProperty("node", "cap", "prop"))
*
* @author Brinda Santh
*/
-class BluePrintExpressionServiceTest {
+class BlueprintExpressionServiceTest {
@Test
fun testInputExpression() {
val node: JsonNode = jacksonObjectMapper().readTree("{ \"get_input\" : \"input-name\" }")
- val expressionData: ExpressionData = BluePrintExpressionService.getExpressionData(node)
+ val expressionData: ExpressionData = BlueprintExpressionService.getExpressionData(node)
assertNotNull(expressionData, " Failed to populate expression data")
assertEquals(expressionData.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData.inputExpression, " Failed to populate input expression data")
@Test
fun testPropertyExpression() {
val node: JsonNode = jacksonObjectMapper().readTree("{ \"get_property\" : [\"SELF\", \"property-name\"] }")
- val expressionData: ExpressionData = BluePrintExpressionService.getExpressionData(node)
+ val expressionData: ExpressionData = BlueprintExpressionService.getExpressionData(node)
assertNotNull(expressionData, " Failed to populate expression data")
assertEquals(expressionData.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData.propertyExpression, " Failed to populate property expression data")
assertEquals("property-name", expressionData.propertyExpression?.propertyName, " Failed to get expected propertyName")
val node1: JsonNode = jacksonObjectMapper().readTree("{ \"get_property\" : [\"SELF\", \"\",\"property-name\", \"resource\", \"name\"] }")
- val expressionData1: ExpressionData = BluePrintExpressionService.getExpressionData(node1)
+ val expressionData1: ExpressionData = BlueprintExpressionService.getExpressionData(node1)
assertNotNull(expressionData1, " Failed to populate expression data")
assertEquals(expressionData1.isExpression, true, "Failed to identify as nested property expression")
assertNotNull(expressionData1.propertyExpression, " Failed to populate nested property expression data")
@Test
fun testAttributeExpression() {
val node: JsonNode = jacksonObjectMapper().readTree("{ \"get_attribute\" : [\"SELF\", \"resource\"] }")
- val expressionData: ExpressionData = BluePrintExpressionService.getExpressionData(node)
+ val expressionData: ExpressionData = BlueprintExpressionService.getExpressionData(node)
assertNotNull(expressionData, " Failed to populate expression data")
assertEquals(expressionData.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData.attributeExpression, " Failed to populate attribute expression data")
assertEquals("resource", expressionData.attributeExpression?.attributeName, " Failed to get expected attributeName")
val node1: JsonNode = jacksonObjectMapper().readTree("{ \"get_attribute\" : [\"SELF\", \"\",\"attribute-name\", \"resource\", \"name\"] }")
- val expressionData1: ExpressionData = BluePrintExpressionService.getExpressionData(node1)
+ val expressionData1: ExpressionData = BlueprintExpressionService.getExpressionData(node1)
assertNotNull(expressionData1, " Failed to populate expression data")
assertEquals(expressionData1.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData1.attributeExpression, " Failed to populate attribute expression data")
fun testOutputOperationExpression() {
val node: JsonNode =
jacksonObjectMapper().readTree("{ \"get_operation_output\": [\"SELF\", \"interface-name\", \"operation-name\", \"output-property-name\"] }")
- val expressionData: ExpressionData = BluePrintExpressionService.getExpressionData(node)
+ val expressionData: ExpressionData = BlueprintExpressionService.getExpressionData(node)
assertNotNull(expressionData, " Failed to populate expression data")
assertEquals(expressionData.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData.operationOutputExpression, " Failed to populate output expression data")
@Test
fun testArtifactExpression() {
val node: JsonNode = jacksonObjectMapper().readTree("{ \"get_artifact\" : [\"SELF\", \"artifact-template\"] }")
- val expressionData: ExpressionData = BluePrintExpressionService.getExpressionData(node)
+ val expressionData: ExpressionData = BlueprintExpressionService.getExpressionData(node)
assertNotNull(expressionData, " Failed to populate expression data")
assertEquals(expressionData.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData.artifactExpression, " Failed to populate Artifact expression data")
assertEquals("artifact-template", expressionData.artifactExpression?.artifactName, " Failed to get expected artifactName")
val node1: JsonNode = jacksonObjectMapper().readTree("{ \"get_artifact\" : [\"SELF\", \"artifact-template\", \"location\", true] }")
- val expressionData1: ExpressionData = BluePrintExpressionService.getExpressionData(node1)
+ val expressionData1: ExpressionData = BlueprintExpressionService.getExpressionData(node1)
assertNotNull(expressionData1, " Failed to populate expression data")
assertEquals(expressionData1.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData1.artifactExpression, " Failed to populate Artifact expression data")
@Test
fun testDSLExpression() {
val node: JsonNode = "*dynamic-rest-source".asJsonPrimitive()
- val expressionData: ExpressionData = BluePrintExpressionService.getExpressionData(node)
+ val expressionData: ExpressionData = BlueprintExpressionService.getExpressionData(node)
assertNotNull(expressionData, " Failed to populate expression data")
assertEquals(expressionData.isExpression, true, "Failed to identify as expression")
assertNotNull(expressionData.dslExpression, " Failed to populate dsl expression data")
package org.onap.ccsdk.cds.controllerblueprints.core.service
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.TestConstants
import kotlin.test.assertNotNull
/**
- * BluePrintRepoFileServiceTest
+ * BlueprintRepoFileServiceTest
* @author Brinda Santh
*
*/
-class BluePrintRepoFileServiceTest {
+class BlueprintRepoFileServiceTest {
private val basePath = TestConstants.PATH_TEST_DEFINITION_TYPE_STARTER
- private val bluePrintRepoFileService = BluePrintRepoFileService(basePath)
+ private val bluePrintRepoFileService = BlueprintRepoFileService(basePath)
@Test
fun testGetDataType() {
assertNotNull(nodeType, "Failed to get ArtifactType from repo")
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testModelNotFound() {
val dataType = bluePrintRepoFileService.getDataType("dt-not-found")
assertNotNull(dataType, "Failed to get DataType from repo")
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.node.NullNode
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.TestConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintRuntimeUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintRuntimeUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
import kotlin.test.assertEquals
*
* @author Brinda Santh
*/
-class BluePrintRuntimeServiceTest {
+class BlueprintRuntimeServiceTest {
private val log = LoggerFactory.getLogger(this::class.toString())
fun `test Resolve NodeTemplate Properties`() {
log.info("************************ testResolveNodeTemplateProperties **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
val inputDataPath = "src/test/resources/data/default-context.json"
fun `test Resolve Relationship Properties`() {
log.info("************************ testResolveRelationshipTemplateProperties **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
val inputDataPath = "src/test/resources/data/default-context.json"
@Test
fun `test resolve NodeTemplate Capability Properties`() {
log.info("************************ testResolveNodeTemplateRequirementProperties **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
val executionContext = bluePrintRuntimeService.getExecutionContext()
- BluePrintRuntimeUtils.assignInputsFromClassPathFile(
+ BlueprintRuntimeUtils.assignInputsFromClassPathFile(
bluePrintRuntimeService.bluePrintContext(),
"data/default-context.json", executionContext
)
fun `test Resolve NodeTemplate Interface Operation Inputs`() {
log.info("************************ testResolveNodeTemplateInterfaceOperationInputs **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
val executionContext = bluePrintRuntimeService.getExecutionContext()
- BluePrintRuntimeUtils.assignInputsFromClassPathFile(
+ BlueprintRuntimeUtils.assignInputsFromClassPathFile(
bluePrintRuntimeService.bluePrintContext(),
"data/default-context.json", executionContext
)
fun `test Resolve NodeTemplate Interface Operation Outputs`() {
log.info("************************ testResolveNodeTemplateInterfaceOperationOutputs **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
bluePrintRuntimeService.setNodeTemplateAttributeValue(
"resource-assignment",
@Test
fun `test NodeTemplate Context Property`() {
log.info("************************ testNodeTemplateContextProperty **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
bluePrintRuntimeService.setNodeTemplateAttributeValue(
"resource-assignment-ra-component", "context1",
fun `test Resolve DSL Properties`() {
log.info("************************ resolveDSLExpression **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
bluePrintRuntimeService.setInputValue("rest-user-name", "sample-username".asJsonPrimitive())
@Test
fun `test Resolve Workflow Outputs`() {
log.info("************************ resolvePropertyAssignments **********************")
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
val assignmentParams = "{\"ipAddress\": \"127.0.0.1\", \"hostName\": \"vnf-host\"}"
@Test
fun `test resolvePropertyDefinitions using sub attributes`() {
- val bluePrintRuntimeService = getBluePrintRuntimeService()
+ val bluePrintRuntimeService = getBlueprintRuntimeService()
bluePrintRuntimeService.setNodeTemplateAttributeValue(
"resource-assignment", "assignment-map",
assertEquals("123", result["resolution"]!!.asText())
}
- private fun getBluePrintRuntimeService(): BluePrintRuntimeService<MutableMap<String, JsonNode>> {
+ private fun getBlueprintRuntimeService(): BlueprintRuntimeService<MutableMap<String, JsonNode>> {
val blueprintBasePath = normalizedPathName(TestConstants.PATH_TEST_BLUEPRINTS_BASECONFIG)
- val blueprintRuntime = BluePrintMetadataUtils.bluePrintRuntime("1234", blueprintBasePath)
- val checkProcessId = blueprintRuntime.get(BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID)
- val checkBasePath = blueprintRuntime.get(BluePrintConstants.PROPERTY_BLUEPRINT_BASE_PATH)
+ val blueprintRuntime = BlueprintMetadataUtils.bluePrintRuntime("1234", blueprintBasePath)
+ val checkProcessId = blueprintRuntime.get(BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID)
+ val checkBasePath = blueprintRuntime.get(BlueprintConstants.PROPERTY_BLUEPRINT_BASE_PATH)
assertEquals(
"1234".asJsonPrimitive(),
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.onap.ccsdk.cds.controllerblueprints.core.TestConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import kotlin.test.BeforeTest
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
-class BluePrintTemplateServiceTest {
+class BlueprintTemplateServiceTest {
- lateinit var blueprintRuntime: BluePrintRuntimeService<*>
+ lateinit var blueprintRuntime: BlueprintRuntimeService<*>
@BeforeTest
fun setup() {
val blueprintBasePath = TestConstants.PATH_TEST_BLUEPRINTS_BASECONFIG
- blueprintRuntime = BluePrintMetadataUtils.bluePrintRuntime("1234", blueprintBasePath)
+ blueprintRuntime = BlueprintMetadataUtils.bluePrintRuntime("1234", blueprintBasePath)
}
@Test
val template = JacksonUtils.getClassPathFileContent("templates/base-config-velocity-template.vtl")
val json = JacksonUtils.getClassPathFileContent("templates/base-config-data-velocity.json")
- val content = BluePrintVelocityTemplateService.generateContent(template, json)
+ val content = BlueprintVelocityTemplateService.generateContent(template, json)
assertNotNull(content, "failed to generate content for velocity template")
}
}
hashMapOf("name" to "Element2", "location" to "Region1")
)
- val content = BluePrintJinjaTemplateService.generateContent(template, json, false, element)
+ val content = BlueprintJinjaTemplateService.generateContent(template, json, false, element)
assertNotNull(content, "failed to generate content for velocity template")
}
}
JacksonUtils.getClassPathFileContent("templates/default-variable-value-velocity-template.vtl")
val json = JacksonUtils.getClassPathFileContent("templates/default-variable-value-data.json")
- val content = BluePrintVelocityTemplateService.generateContent(template, json)
+ val content = BlueprintVelocityTemplateService.generateContent(template, json)
// first line represents a variable whose value was successfully retrieved, second line contains a variable
// whose value could not be evaluated
val expected = "sample-hostname\n\${node0_backup_router_address}"
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.data.EdgeLabel
import org.onap.ccsdk.cds.controllerblueprints.core.data.Graph
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.toGraph
import kotlin.test.assertNotNull
-class BluePrintWorkflowServiceTest {
+class BlueprintWorkflowServiceTest {
@Test
fun testSimpleFlow() {
runBlocking {
val graph = "[START>A/SUCCESS, A>B/SUCCESS, B>C/SUCCESS, C>D/SUCCESS, D>E/SUCCESS, E>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "B", "C", "D", "E"), null)
val input = "123456"
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(), input)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(), input)
assertNotNull(response, "failed to get response")
}
}
async {
val graph = "[START>A/SUCCESS, A>B/SUCCESS, B>C/SUCCESS, C>D/SUCCESS, D>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "B", "C", "D"), null)
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(it), it)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(it), it)
assertNotNull(response, "failed to get response")
}
}
runBlocking {
val graph = "[START>A/SUCCESS, A>B/SUCCESS, B>C/SUCCESS, C>D/SUCCESS, D>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "C", "D", "E"), arrayListOf("B"))
val input = "123456"
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(), input)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(), input)
assertNotNull(response, "failed to get response")
}
}
runBlocking {
val graph = "[START>A/SUCCESS, A>B/SUCCESS, B>C/SUCCESS, C>D/SUCCESS, D>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "C", "D", "E"), null)
val input = "123456"
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(), input)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(), input)
assertNotNull(response, "failed to get response")
}
}
runBlocking {
val graph = "[START>A/SUCCESS, A>TO/SUCCESS, TO>C/SUCCESS, C>D/SUCCESS, D>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "TO", "C", "D", "E"), null)
val input = "123456"
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(), input)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(), input)
assertNotNull(response, "failed to get response")
}
}
runBlocking {
val graph = "[START>A/SUCCESS, A>B/SUCCESS, A>C/FAILURE, B>D/SUCCESS, C>D/SUCCESS, D>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "B", "C", "D", "E"), null)
val input = "123456"
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(), input)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(), input)
assertNotNull(response, "failed to get response")
}
}
// Failure Flow
val failurePatGraph = "[START>A/SUCCESS, A>B/SUCCESS, A>C/FAILURE, B>D/SUCCESS, C>D/SUCCESS, D>END/SUCCESS]"
.toGraph()
- val failurePathWorkflow = TestBluePrintWorkFlowService()
+ val failurePathWorkflow = TestBlueprintWorkFlowService()
failurePathWorkflow.simulatedState = prepareSimulation(
arrayListOf("B", "C", "D", "E"),
arrayListOf("A")
)
val failurePathWorkflowInput = "123456"
- val failurePathResponse = failurePathWorkflow.executeWorkflow(failurePatGraph, mockBluePrintRuntimeService(), failurePathWorkflowInput)
+ val failurePathResponse = failurePathWorkflow.executeWorkflow(failurePatGraph, mockBlueprintRuntimeService(), failurePathWorkflowInput)
assertNotNull(failurePathResponse, "failed to get response")
}
}
runBlocking {
val graph = "[START>A/SUCCESS, A>B/SUCCESS, A>C/FAILURE, C>D/SUCCESS, D>E/SUCCESS, B>E/SUCCESS, E>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "B", "C", "D", "E"), null)
val input = "123456"
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(), input)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(), input)
assertNotNull(response, "failed to get response")
}
}
runBlocking {
val graph = "[START>A/SUCCESS, A>B/SUCCESS, A>C/SUCCESS, B>D/SUCCESS, C>D/SUCCESS, D>END/SUCCESS]"
.toGraph()
- val simpleWorkflow = TestBluePrintWorkFlowService()
+ val simpleWorkflow = TestBlueprintWorkFlowService()
simpleWorkflow.simulatedState = prepareSimulation(arrayListOf("A", "B", "C", "D"), null)
val input = "123456"
- val response = simpleWorkflow.executeWorkflow(graph, mockBluePrintRuntimeService(), input)
+ val response = simpleWorkflow.executeWorkflow(graph, mockBlueprintRuntimeService(), input)
assertNotNull(response, "failed to get response")
}
}
- private fun mockBluePrintRuntimeService(): BluePrintRuntimeService<*> {
- return mockBluePrintRuntimeService("123456")
+ private fun mockBlueprintRuntimeService(): BlueprintRuntimeService<*> {
+ return mockBlueprintRuntimeService("123456")
}
- private fun mockBluePrintRuntimeService(id: String): BluePrintRuntimeService<*> {
- val bluePrintRuntimeService = mockk<BluePrintRuntimeService<*>>()
+ private fun mockBlueprintRuntimeService(id: String): BlueprintRuntimeService<*> {
+ val bluePrintRuntimeService = mockk<BlueprintRuntimeService<*>>()
every { bluePrintRuntimeService.id() } returns id
return bluePrintRuntimeService
}
}
}
-class TestBluePrintWorkFlowService :
- AbstractBluePrintWorkFlowService<String, String>() {
+class TestBlueprintWorkFlowService :
+ AbstractBlueprintWorkFlowService<String, String>() {
- val log = logger(TestBluePrintWorkFlowService::class)
+ val log = logger(TestBlueprintWorkFlowService::class)
lateinit var simulatedState: MutableMap<String, EdgeLabel>
return EdgeLabel.SUCCESS
}
- override suspend fun executeWorkflow(graph: Graph, bluePrintRuntimeService: BluePrintRuntimeService<*>, input: String): String {
+ override suspend fun executeWorkflow(graph: Graph, bluePrintRuntimeService: BlueprintRuntimeService<*>, input: String): String {
log.info("Executing Graph : $graph")
this.graph = graph
this.workflowId = bluePrintRuntimeService.id()
if (!workflowActor.isClosedForSend) {
workflowActor().send(startMessage)
} else {
- throw BluePrintProcessorException("workflow actor is closed for send $workflowActor")
+ throw BlueprintProcessorException("workflow actor is closed for send $workflowActor")
}
return startMessage.output.await()
}
kotlinx.coroutines.delay(2)
}
}
- return simulatedState[node.id] ?: throw BluePrintException("failed to get status for the node($node)")
+ return simulatedState[node.id] ?: throw BlueprintException("failed to get status for the node($node)")
}
override suspend fun prepareNodeSkipMessage(node: Graph.Node): NodeSkipMessage<String, String> {
nodeInput: String,
nodeOutput: String
): EdgeLabel {
- return simulatedState[node.id] ?: throw BluePrintException("failed to get status for the node($node)")
+ return simulatedState[node.id] ?: throw BlueprintException("failed to get status for the node($node)")
}
override suspend fun cancelNode(
import java.nio.file.Paths
import kotlin.test.assertTrue
-class BluePrintFileUtilsTest {
+class BlueprintFileUtilsTest {
@Test
fun testNewBlueprint() = runBlocking {
val targetPath: String = Paths.get("target").toUri().toURL().path.plus("/bp-new-test")
- BluePrintFileUtils.createEmptyBluePrint(targetPath)
+ BlueprintFileUtils.createEmptyBlueprint(targetPath)
}
@Test
val targetDir = File(targetPath)
targetDir.deleteOnExit()
// Copy the BP file
- BluePrintFileUtils.copyBluePrint(sourcePath, targetDir.absolutePath)
+ BlueprintFileUtils.copyBlueprint(sourcePath, targetDir.absolutePath)
assertTrue(targetDir.exists(), "faield to copy blueprint to ${targetDir.absolutePath}")
// Delete Type Files
- BluePrintFileUtils.deleteBluePrintTypes(targetDir.absolutePath)
+ BlueprintFileUtils.deleteBlueprintTypes(targetDir.absolutePath)
// Generate the Type Files
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(sourcePath)
+ val bluePrintContext = BlueprintMetadataUtils.getBlueprintContext(sourcePath)
bluePrintContext.rootPath = targetDir.absolutePath
- BluePrintFileUtils.writeBluePrintTypes(bluePrintContext)
+ BlueprintFileUtils.writeBlueprintTypes(bluePrintContext)
}
}
import kotlinx.coroutines.runBlocking
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintRetryException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintRetryException
-class BluePrintIOUtilsTest {
+class BlueprintIOUtilsTest {
@Test
fun testRetry() {
"success"
}
val exceptionBlock = { e: Exception ->
- if (e is BluePrintRetryException) {
+ if (e is BlueprintRetryException) {
println("this is blueprint error")
} else {
throw e
}
}
- BluePrintIOUtils.retry<String>(4, 0, 500, executionBlock, exceptionBlock)
+ BlueprintIOUtils.retry<String>(4, 0, 500, executionBlock, exceptionBlock)
}
}
}
import org.onap.ccsdk.cds.controllerblueprints.core.TestConstants
import org.onap.ccsdk.cds.controllerblueprints.core.data.ToscaMetaData
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintCompileCache
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintCompileCache
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertNull
import kotlin.test.assertTrue
-class BluePrintMetadataUtilsTest {
+class BlueprintMetadataUtilsTest {
@Test
fun testToscaMetaData() {
runBlocking {
val basePath = TestConstants.PATH_TEST_BLUEPRINTS_BASECONFIG
- val toscaMetaData: ToscaMetaData = BluePrintMetadataUtils.toscaMetaData(basePath)
+ val toscaMetaData: ToscaMetaData = BlueprintMetadataUtils.toscaMetaData(basePath)
assertNotNull(toscaMetaData, "Missing Tosca Definition Object")
assertNotNull(toscaMetaData.toscaMetaFileVersion, "Missing Tosca Metadata Version")
assertNotNull(toscaMetaData.csarVersion, "Missing CSAR version")
}
@Test
- fun testKotlinBluePrintContext() {
+ fun testKotlinBlueprintContext() {
runBlocking {
val path = normalizedPathName("src/test/resources/compile")
- val blueprintContext = BluePrintMetadataUtils.getBluePrintContext(path)
+ val blueprintContext = BlueprintMetadataUtils.getBlueprintContext(path)
assertNotNull(blueprintContext, "failed to get blueprint context")
assertNotNull(blueprintContext.serviceTemplate, "failed to get blueprint context service template")
assertNotNull(blueprintContext.serviceTemplate, "failed to get blueprint context service template")
assertNotNull(blueprintContext.otherDefinitions, "failed to get blueprint contextother definitions")
- var cachePresent = BluePrintCompileCache.hasClassLoader(path)
+ var cachePresent = BlueprintCompileCache.hasClassLoader(path)
assertTrue(cachePresent, "failed to generate cache key ($path)")
/** Cleaning Cache */
- BluePrintCompileCache.cleanClassLoader(path)
- cachePresent = BluePrintCompileCache.hasClassLoader(path)
+ BlueprintCompileCache.cleanClassLoader(path)
+ cachePresent = BlueprintCompileCache.hasClassLoader(path)
assertTrue(!cachePresent, "failed to remove cache key ($path)")
}
}
fun environmentDataTest() {
val environmentPath = "./src/test/resources/environments"
- val properties = BluePrintMetadataUtils.bluePrintEnvProperties(environmentPath)
+ val properties = BlueprintMetadataUtils.bluePrintEnvProperties(environmentPath)
assertNotNull(properties, "Could not read the properties")
assertEquals(properties.getProperty("blueprintsprocessor.database.alt1.username"), "username1", "failed 1")
package org.onap.ccsdk.cds.controllerblueprints.core.utils
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.slf4j.LoggerFactory
import kotlin.test.assertNotNull
import kotlin.test.assertTrue
val rootJson = JacksonUtils.jsonNodeFromClassPathFile(filePath)
assertNotNull(rootJson, "Failed to get all type data json node")
val intValue = rootJson.get("intValue")
- assertTrue(JacksonUtils.checkJsonNodeValueOfType(BluePrintConstants.DATA_TYPE_INTEGER, intValue), "Failed to get as int value")
+ assertTrue(JacksonUtils.checkJsonNodeValueOfType(BlueprintConstants.DATA_TYPE_INTEGER, intValue), "Failed to get as int value")
val floatValue = rootJson.get("floatValue")
- assertTrue(JacksonUtils.checkJsonNodeValueOfType(BluePrintConstants.DATA_TYPE_FLOAT, floatValue), "Failed to get as float value")
+ assertTrue(JacksonUtils.checkJsonNodeValueOfType(BlueprintConstants.DATA_TYPE_FLOAT, floatValue), "Failed to get as float value")
val stringValue = rootJson.get("stringValue")
- assertTrue(JacksonUtils.checkJsonNodeValueOfType(BluePrintConstants.DATA_TYPE_STRING, stringValue), "Failed to get as string value")
+ assertTrue(JacksonUtils.checkJsonNodeValueOfType(BlueprintConstants.DATA_TYPE_STRING, stringValue), "Failed to get as string value")
val booleanValue = rootJson.get("booleanValue")
- assertTrue(JacksonUtils.checkJsonNodeValueOfType(BluePrintConstants.DATA_TYPE_BOOLEAN, booleanValue), "Failed to get as boolean value")
+ assertTrue(JacksonUtils.checkJsonNodeValueOfType(BlueprintConstants.DATA_TYPE_BOOLEAN, booleanValue), "Failed to get as boolean value")
val arrayStringValue = rootJson.get("arrayStringValue")
- assertTrue(JacksonUtils.checkJsonNodeValueOfType(BluePrintConstants.DATA_TYPE_LIST, arrayStringValue), "Failed to get as List value")
+ assertTrue(JacksonUtils.checkJsonNodeValueOfType(BlueprintConstants.DATA_TYPE_LIST, arrayStringValue), "Failed to get as List value")
// FIX needed for ("complex type JSON & MAP")
// val mapValue = rootJson.get("mapValue")
- // assertTrue(JacksonUtils.checkJsonNodeValueOfType(BluePrintConstants.DATA_TYPE_MAP, mapValue), "Failed to get as Map value")
+ // assertTrue(JacksonUtils.checkJsonNodeValueOfType(BlueprintConstants.DATA_TYPE_MAP, mapValue), "Failed to get as Map value")
- assertTrue(!JacksonUtils.checkJsonNodeValueOfType(BluePrintConstants.DATA_TYPE_LIST, stringValue), "Negative type failed")
+ assertTrue(!JacksonUtils.checkJsonNodeValueOfType(BlueprintConstants.DATA_TYPE_LIST, stringValue), "Negative type failed")
}
}
package org.onap.ccsdk.cds.controllerblueprints.core.utils
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.LOG_PROTECT
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.LOG_PROTECT
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.utils.PropertyDefinitionUtils.Companion.hasLogProtect
import kotlin.test.assertFalse
package cba.scripts
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.dataType
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.AbstractBluePrintDefinitions
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.AbstractBlueprintDefinitions
-class ActivateBlueprintDefinitions : AbstractBluePrintDefinitions() {
+class ActivateBlueprintDefinitions : AbstractBlueprintDefinitions() {
override fun serviceTemplate(): ServiceTemplate {
/** Sample Definitions */
val customDataType = dataType(
"custom-datatype", "1.0.0",
- BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT, ""
+ BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT, ""
) {
- property("name", BluePrintConstants.DATA_TYPE_STRING, true, "")
- property("value", BluePrintConstants.DATA_TYPE_STRING, true, "")
+ property("name", BlueprintConstants.DATA_TYPE_STRING, true, "")
+ property("value", BlueprintConstants.DATA_TYPE_STRING, true, "")
}
/** Loading to definitions */
addOtherDefinition("datatype-custom-datatype", customDataType)
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
@Service("default-artifact-definition-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintArtifactDefinitionValidatorImpl(
- private val bluePrintTypeValidatorService: BluePrintTypeValidatorService
-) : BluePrintArtifactDefinitionValidator {
+open class BlueprintArtifactDefinitionValidatorImpl(
+ private val bluePrintTypeValidatorService: BlueprintTypeValidatorService
+) : BlueprintArtifactDefinitionValidator {
- private val log = LoggerFactory.getLogger(BluePrintArtifactDefinitionValidatorImpl::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintArtifactDefinitionValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
var paths: MutableList<String> = arrayListOf()
override fun validate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
artifactDefinition: ArtifactDefinition
) {
val completePath = bluePrintContext.rootPath.plus(File.separator).plus(file)
check(File(completePath).exists()) {
- throw BluePrintException("couldn't find file ($completePath)")
+ throw BlueprintException("couldn't find file ($completePath)")
}
// Perform Extension Validation
open fun checkValidArtifactType(artifactDefinitionName: String, artifactTypeName: String) {
val artifactType = bluePrintContext.serviceTemplate.artifactTypes?.get(artifactTypeName)
- ?: throw BluePrintException("failed to get artifactType($artifactTypeName) for ArtifactDefinition($artifactDefinitionName)")
+ ?: throw BlueprintException("failed to get artifactType($artifactTypeName) for ArtifactDefinition($artifactDefinitionName)")
checkValidArtifactTypeDerivedFrom(artifactTypeName, artifactType.derivedFrom)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun checkValidArtifactTypeDerivedFrom(artifactTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validArtifactTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException("failed to get artifactType($artifactTypeName)'s derivedFrom($derivedFrom) definition")
+ check(BlueprintTypes.validArtifactTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException("failed to get artifactType($artifactTypeName)'s derivedFrom($derivedFrom) definition")
}
}
private fun validateExtension(referencePrefix: String, name: String, artifactDefinition: ArtifactDefinition) {
val customValidators = bluePrintTypeValidatorService
- .bluePrintValidators(referencePrefix, BluePrintArtifactDefinitionValidator::class.java)
+ .bluePrintValidators(referencePrefix, BlueprintArtifactDefinitionValidator::class.java)
customValidators?.let {
it.forEach { validator ->
package org.onap.ccsdk.cds.controllerblueprints.validation
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.stereotype.Service
@Service("default-artifact-type-validator")
-open class BluePrintArtifactTypeValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
- BluePrintArtifactTypeValidator {
+open class BlueprintArtifactTypeValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) :
+ BlueprintArtifactTypeValidator {
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, artifactType: ArtifactType) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, artifactType: ArtifactType) {
artifactType.properties?.let {
bluePrintTypeValidatorService.validatePropertyDefinitions(bluePrintRuntimeService, artifactType.properties!!)
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.format
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintAttributeDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintAttributeDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
@Service("default-attribute-definition-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintAttributeDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
- BluePrintAttributeDefinitionValidator {
+open class BlueprintAttributeDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) :
+ BlueprintAttributeDefinitionValidator {
- private val log = LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintServiceTemplateValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
override fun validate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
attributeDefinition: AttributeDefinition
) {
val dataType: String = attributeDefinition.type
when {
- BluePrintTypes.validPrimitiveTypes().contains(dataType) -> {
+ BlueprintTypes.validPrimitiveTypes().contains(dataType) -> {
// Do Nothing
}
- BluePrintTypes.validComplexTypes().contains(dataType) -> {
+ BlueprintTypes.validComplexTypes().contains(dataType) -> {
// Do Nothing
}
- BluePrintTypes.validCollectionTypes().contains(dataType) -> {
+ BlueprintTypes.validCollectionTypes().contains(dataType) -> {
val entrySchemaType: String = attributeDefinition.entrySchema?.type
- ?: throw BluePrintException("Entry schema for DataType ($dataType) for the property ($name) not found")
+ ?: throw BlueprintException("Entry schema for DataType ($dataType) for the property ($name) not found")
checkPrimitiveOrComplex(entrySchemaType, name)
}
else -> checkPropertyDataType(dataType, name)
}
private fun checkPrimitiveOrComplex(dataType: String, propertyName: String): Boolean {
- if (BluePrintTypes.validPrimitiveTypes().contains(dataType) || checkDataType(dataType)) {
+ if (BlueprintTypes.validPrimitiveTypes().contains(dataType) || checkDataType(dataType)) {
return true
} else {
- throw BluePrintException("DataType($dataType) for the attribute($propertyName) is not valid")
+ throw BlueprintException("DataType($dataType) for the attribute($propertyName) is not valid")
}
}
private fun checkPropertyDataType(dataTypeName: String, propertyName: String) {
val dataType = bluePrintRuntimeService.bluePrintContext().serviceTemplate.dataTypes?.get(dataTypeName)
- ?: throw BluePrintException(format("DataType ({}) for the property ({}) not found", dataTypeName, propertyName))
+ ?: throw BlueprintException(format("DataType ({}) for the property ({}) not found", dataTypeName, propertyName))
checkValidDataTypeDerivedFrom(propertyName, dataType.derivedFrom)
}
}
open fun checkValidDataTypeDerivedFrom(dataTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException("Failed to get DataType($dataTypeName)'s derivedFrom($derivedFrom) definition ")
+ check(BlueprintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException("Failed to get DataType($dataTypeName)'s derivedFrom($derivedFrom) definition ")
}
}
}
package org.onap.ccsdk.cds.controllerblueprints.validation
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintDataTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintDataTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.stereotype.Service
@Service("default-data-type-validator")
-open class BluePrintDataTypeValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintDataTypeValidator {
+open class BlueprintDataTypeValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) : BlueprintDataTypeValidator {
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, dataType: DataType) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, dataType: DataType) {
dataType.properties?.let {
bluePrintTypeValidatorService.validatePropertyDefinitions(bluePrintRuntimeService, dataType.properties!!)
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDictionaryConstants
import java.util.UUID
@Service("bluePrintDesignTimeValidatorService")
-open class BluePrintDesignTimeValidatorService(
- private val bluePrintTypeValidatorService: BluePrintTypeValidatorService,
+open class BlueprintDesignTimeValidatorService(
+ private val bluePrintTypeValidatorService: BlueprintTypeValidatorService,
private val resourceDefinitionValidator: ResourceDefinitionValidator
) :
- BluePrintValidatorService {
+ BlueprintValidatorService {
- private val log = LoggerFactory.getLogger(BluePrintDesignTimeValidatorService::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintDesignTimeValidatorService::class.toString())
- override suspend fun validateBluePrints(basePath: String): Boolean {
+ override suspend fun validateBlueprints(basePath: String): Boolean {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(UUID.randomUUID().toString(), basePath)
- return validateBluePrints(bluePrintRuntimeService)
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(UUID.randomUUID().toString(), basePath)
+ return validateBlueprints(bluePrintRuntimeService)
}
- override suspend fun validateBluePrints(bluePrintRuntimeService: BluePrintRuntimeService<*>): Boolean {
+ override suspend fun validateBlueprints(bluePrintRuntimeService: BlueprintRuntimeService<*>): Boolean {
bluePrintTypeValidatorService.validateServiceTemplate(
bluePrintRuntimeService, "service_template",
// Validate Resource Definitions
validateResourceDefinitions(bluePrintRuntimeService)
- if (bluePrintRuntimeService.getBluePrintError().errors.size > 0) {
- throw BluePrintException("failed in blueprint validation : ${bluePrintRuntimeService.getBluePrintError().errors.joinToString("\n")}")
+ if (bluePrintRuntimeService.getBlueprintError().errors.size > 0) {
+ throw BlueprintException("failed in blueprint validation : ${bluePrintRuntimeService.getBlueprintError().errors.joinToString("\n")}")
}
return true
}
- private fun validateResourceDefinitions(bluePrintRuntimeService: BluePrintRuntimeService<*>) {
+ private fun validateResourceDefinitions(bluePrintRuntimeService: BlueprintRuntimeService<*>) {
// Validate Resource Dictionary
val blueprintBasePath = bluePrintRuntimeService.bluePrintContext().rootPath
val resourceDefinitionsPath = blueprintBasePath.plus(File.separator)
- .plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR).plus(File.separator)
+ .plus(BlueprintConstants.TOSCA_DEFINITIONS_DIR).plus(File.separator)
.plus("${ResourceDictionaryConstants.PATH_RESOURCE_DEFINITION_TYPE}.json")
val resourceDefinitionFile = File(resourceDefinitionsPath)
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityAssignment
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementAssignment
import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.validation.utils.PropertyAssignmentValidationUtils
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
@Service("default-node-template-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintNodeTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
- BluePrintNodeTemplateValidator {
+open class BlueprintNodeTemplateValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) :
+ BlueprintNodeTemplateValidator {
- private val log = LoggerFactory.getLogger(BluePrintNodeTemplateValidatorImpl::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintNodeTemplateValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
lateinit var propertyAssignmentValidationUtils: PropertyAssignmentValidationUtils
var paths: MutableList<String> = arrayListOf()
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
log.debug("Validating NodeTemplate($name)")
this.bluePrintRuntimeService = bluePrintRuntimeService
val type: String = nodeTemplate.type
val nodeType: NodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(type)
- ?: throw BluePrintException("Failed to get NodeType($type) definition for NodeTemplate($name)")
+ ?: throw BlueprintException("Failed to get NodeType($type) definition for NodeTemplate($name)")
nodeTemplate.properties?.let {
propertyAssignmentValidationUtils
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateArtifactDefinitions(artifacts: MutableMap<String, ArtifactDefinition>) {
paths.add("artifacts")
artifacts.forEach { artifactDefinitionName, artifactDefinition ->
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateCapabilityAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
val capabilities = nodeTemplate.capabilities
paths.add("capabilities")
paths.add(capabilityName)
val capabilityDefinition = nodeType.capabilities?.get(capabilityName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"Failed to get NodeTemplate($nodeTemplateName) capability definition ($capabilityName) " +
"from NodeType(${nodeTemplate.type})"
)
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateCapabilityAssignment(
nodeTemplateName: String,
capabilityName: String,
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateRequirementAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
val requirements = nodeTemplate.requirements
paths.add("requirements")
requirements?.forEach { requirementName, requirementAssignment ->
paths.add(requirementName)
val requirementDefinition = nodeType.requirements?.get(requirementName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"Failed to get NodeTemplate($nodeTemplateName) requirement definition ($requirementName) from" +
" NodeType(${nodeTemplate.type})"
)
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateRequirementAssignment(
nodeTemplateName: String,
requirementAssignmentName: String,
val capabilityName = requirementAssignment.capability
val relationship = requirementAssignment.relationship!!
- check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {
- throw BluePrintException("Failed to get relationship type ($relationship) for NodeTemplate($nodeTemplateName)'s requirement($requirementAssignmentName)")
+ check(BlueprintTypes.validRelationShipDerivedFroms.contains(relationship)) {
+ throw BlueprintException("Failed to get relationship type ($relationship) for NodeTemplate($nodeTemplateName)'s requirement($requirementAssignmentName)")
}
val relationShipNodeTemplate = bluePrintContext.serviceTemplate.topologyTemplate?.nodeTemplates?.get(requirementNodeTemplateName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"Failed to get requirement NodeTemplate($requirementNodeTemplateName)'s " +
"for NodeTemplate($nodeTemplateName) requirement($requirementAssignmentName)"
)
relationShipNodeTemplate.capabilities?.get(capabilityName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"Failed to get requirement NodeTemplate($requirementNodeTemplateName)'s " +
"capability($capabilityName) for NodeTemplate ($nodeTemplateName)'s requirement($requirementAssignmentName)"
)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInterfaceAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
val interfaces = nodeTemplate.interfaces
interfaces?.forEach { interfaceAssignmentName, interfaceAssignment ->
paths.add(interfaceAssignmentName)
val interfaceDefinition = nodeType.interfaces?.get(interfaceAssignmentName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"Failed to get NodeTemplate($nodeTemplateName) interface definition ($interfaceAssignmentName) from" +
" NodeType(${nodeTemplate.type})"
)
paths.removeAt(paths.lastIndex)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInterfaceAssignment(
nodeTemplateName: String,
interfaceAssignmentName: String,
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateInterfaceOperationsAssignment(
nodeTemplateName: String,
interfaceAssignmentName: String,
it.forEach { operationAssignmentName, operationAssignments ->
val operationDefinition = interfaceDefinition.operations?.get(operationAssignmentName)
- ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) operation definition ($operationAssignmentName)")
+ ?: throw BlueprintException("Failed to get NodeTemplate($nodeTemplateName) operation definition ($operationAssignmentName)")
log.debug(
"Validation NodeTemplate($nodeTemplateName) Interface($interfaceAssignmentName) Operation " +
inputs?.forEach { propertyName, propertyAssignment ->
val propertyDefinition = operationDefinition.inputs?.get(propertyName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"Failed to get NodeTemplate($nodeTemplateName) operation " +
"definition ($operationAssignmentName) property definition($propertyName)"
)
outputs?.forEach { propertyName, propertyAssignment ->
val propertyDefinition = operationDefinition.outputs?.get(propertyName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"Failed to get NodeTemplate($nodeTemplateName) operation definition ($operationAssignmentName) " +
"output property definition($propertyName)"
)
private fun validateExtension(referencePrefix: String, name: String, nodeTemplate: NodeTemplate) {
val customValidator = bluePrintTypeValidatorService
- .bluePrintValidator(referencePrefix, BluePrintNodeTemplateValidator::class.java)
+ .bluePrintValidator(referencePrefix, BlueprintNodeTemplateValidator::class.java)
customValidator?.let {
it.validate(bluePrintRuntimeService, name, nodeTemplate)
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.OperationDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
@Service("default-node-type-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintNodeTypeValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintNodeTypeValidator {
+open class BlueprintNodeTypeValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) : BlueprintNodeTypeValidator {
- private val log = LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintServiceTemplateValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
var paths: MutableList<String> = arrayListOf()
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTypeName: String, nodeType: NodeType) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, nodeTypeName: String, nodeType: NodeType) {
log.trace("Validating NodeType($nodeTypeName)")
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
// Check Derived From
checkValidNodeTypesDerivedFrom(nodeTypeName, derivedFrom)
- if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {
+ if (!BlueprintTypes.rootNodeTypes().contains(derivedFrom)) {
bluePrintContext.serviceTemplate.nodeTypes?.get(derivedFrom)
- ?: throw BluePrintException("Failed to get derivedFrom NodeType($derivedFrom)'s for NodeType($nodeTypeName)")
+ ?: throw BlueprintException("Failed to get derivedFrom NodeType($derivedFrom)'s for NodeType($nodeTypeName)")
}
nodeType.attributes?.let {
}
fun checkValidNodeTypesDerivedFrom(nodeTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validNodeTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException("Failed to get node type ($nodeTypeName)'s derivedFrom($derivedFrom) definition ")
+ check(BlueprintTypes.validNodeTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException("Failed to get node type ($nodeTypeName)'s derivedFrom($derivedFrom) definition ")
}
}
capabilityDefinition: CapabilityDefinition
) {
val capabilityType = capabilityDefinition.type
- check(BluePrintTypes.validCapabilityTypes.contains(capabilityType)) {
- throw BluePrintException("failed to get CapabilityType($capabilityType) for NodeType($nodeTypeName)")
+ check(BlueprintTypes.validCapabilityTypes.contains(capabilityType)) {
+ throw BlueprintException("failed to get CapabilityType($capabilityType) for NodeType($nodeTypeName)")
}
}
val capabilityName = requirementDefinition.capability
val relationship = requirementDefinition.relationship!!
- check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {
- throw BluePrintException("failed to get relationship($relationship) for NodeType($nodeTypeName)'s requirement($requirementDefinitionName)")
+ check(BlueprintTypes.validRelationShipDerivedFroms.contains(relationship)) {
+ throw BlueprintException("failed to get relationship($relationship) for NodeType($nodeTypeName)'s requirement($requirementDefinitionName)")
}
val relationShipNodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(requirementNodeTypeName)
- ?: throw BluePrintException("failed to get requirement NodeType($requirementNodeTypeName)'s for requirement($requirementDefinitionName) ")
+ ?: throw BlueprintException("failed to get requirement NodeType($requirementNodeTypeName)'s for requirement($requirementDefinitionName) ")
relationShipNodeType.capabilities?.get(capabilityName)
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"failed to get requirement NodeType($requirementNodeTypeName)'s " +
"capability($nodeTypeName) for NodeType ($capabilityName)'s requirement($requirementDefinitionName) "
)
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.format
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintPropertyDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintPropertyDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
@Service("default-property-definition-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintPropertyDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
- BluePrintPropertyDefinitionValidator {
+open class BlueprintPropertyDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) :
+ BlueprintPropertyDefinitionValidator {
- private val log = LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintServiceTemplateValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, propertyDefinition: PropertyDefinition) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, propertyDefinition: PropertyDefinition) {
this.bluePrintRuntimeService = bluePrintRuntimeService
log.trace("Validating PropertyDefinition($name)")
val dataType: String = propertyDefinition.type
when {
- BluePrintTypes.validPrimitiveTypes().contains(dataType) -> {
+ BlueprintTypes.validPrimitiveTypes().contains(dataType) -> {
// Do Nothing
}
- BluePrintTypes.validComplexTypes().contains(dataType) -> {
+ BlueprintTypes.validComplexTypes().contains(dataType) -> {
// Do Nothing
}
- BluePrintTypes.validCollectionTypes().contains(dataType) -> {
+ BlueprintTypes.validCollectionTypes().contains(dataType) -> {
val entrySchemaType: String = propertyDefinition.entrySchema?.type
- ?: throw BluePrintException(format("Entry schema for DataType ({}) for the property ({}) not found", dataType, name))
+ ?: throw BlueprintException(format("Entry schema for DataType ({}) for the property ({}) not found", dataType, name))
checkPrimitiveOrComplex(entrySchemaType, name)
}
else -> checkPropertyDataType(dataType, name)
}
private fun checkPrimitiveOrComplex(dataType: String, propertyName: String): Boolean {
- if (BluePrintTypes.validPrimitiveTypes().contains(dataType) || checkDataType(dataType)) {
+ if (BlueprintTypes.validPrimitiveTypes().contains(dataType) || checkDataType(dataType)) {
return true
} else {
- throw BluePrintException(format("DataType({}) for the property({}) is not valid", dataType, propertyName))
+ throw BlueprintException(format("DataType({}) for the property({}) is not valid", dataType, propertyName))
}
}
private fun checkPropertyDataType(dataTypeName: String, propertyName: String) {
val dataType = bluePrintRuntimeService.bluePrintContext().serviceTemplate.dataTypes?.get(dataTypeName)
- ?: throw BluePrintException(format("DataType ({}) for the property ({}) not found", dataTypeName, propertyName))
+ ?: throw BlueprintException(format("DataType ({}) for the property ({}) not found", dataTypeName, propertyName))
checkValidDataTypeDerivedFrom(propertyName, dataType.derivedFrom)
}
}
open fun checkValidDataTypeDerivedFrom(dataTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException(format("Failed to get DataType({})'s derivedFrom({}) definition ", dataTypeName, derivedFrom))
+ check(BlueprintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException(format("Failed to get DataType({})'s derivedFrom({}) definition ", dataTypeName, derivedFrom))
}
}
}
import com.google.common.base.Preconditions
import org.apache.commons.lang3.StringUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintServiceTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintServiceTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
@Service("default-service-template-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintServiceTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
- BluePrintServiceTemplateValidator {
+open class BlueprintServiceTemplateValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) :
+ BlueprintServiceTemplateValidator {
- private val log = LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintServiceTemplateValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var error: BluePrintError
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var error: BlueprintError
var paths: MutableList<String> = arrayListOf()
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, serviceTemplate: ServiceTemplate) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, serviceTemplate: ServiceTemplate) {
log.trace("Validating Service Template..")
try {
this.bluePrintRuntimeService = bluePrintRuntimeService
- this.error = bluePrintRuntimeService.getBluePrintError()
+ this.error = bluePrintRuntimeService.getBlueprintError()
serviceTemplate.metadata?.let { validateMetadata(serviceTemplate.metadata!!) }
serviceTemplate.dataTypes?.let { validateDataTypes(serviceTemplate.dataTypes!!) }
serviceTemplate.topologyTemplate?.let { validateTopologyTemplate(serviceTemplate.topologyTemplate!!) }
} catch (e: Exception) {
log.error("failed in blueprint service template validation", e)
- error.addError(BluePrintConstants.PATH_SERVICE_TEMPLATE, paths.joinToString(BluePrintConstants.PATH_DIVIDER), e.message!!)
+ error.addError(BlueprintConstants.PATH_SERVICE_TEMPLATE, paths.joinToString(BlueprintConstants.PATH_DIVIDER), e.message!!)
}
}
fun validateMetadata(metaDataMap: MutableMap<String, String>) {
- paths.add(BluePrintConstants.PATH_METADATA)
+ paths.add(BlueprintConstants.PATH_METADATA)
- val templateName = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_NAME]
- val templateVersion = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_VERSION]
- val templateTags = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_TAGS]
- val templateAuthor = metaDataMap[BluePrintConstants.METADATA_TEMPLATE_AUTHOR]
+ val templateName = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_NAME]
+ val templateVersion = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_VERSION]
+ val templateTags = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_TAGS]
+ val templateAuthor = metaDataMap[BlueprintConstants.METADATA_TEMPLATE_AUTHOR]
Preconditions.checkArgument(StringUtils.isNotBlank(templateName), "failed to get template name metadata")
Preconditions.checkArgument(StringUtils.isNotBlank(templateVersion), "failed to get template version metadata")
fun validateDataTypes(dataTypes: MutableMap<String, DataType>) {
- paths.add(BluePrintConstants.PATH_DATA_TYPES)
+ paths.add(BlueprintConstants.PATH_DATA_TYPES)
dataTypes.forEach { dataTypeName, dataType ->
// Validate Single Data Type
bluePrintTypeValidatorService.validateDataType(bluePrintRuntimeService, dataTypeName, dataType)
}
fun validateArtifactTypes(artifactTypes: MutableMap<String, ArtifactType>) {
- paths.add(BluePrintConstants.PATH_ARTIFACT_TYPES)
+ paths.add(BlueprintConstants.PATH_ARTIFACT_TYPES)
artifactTypes.forEach { artifactName, artifactType ->
// Validate Single Artifact Type
bluePrintTypeValidatorService.validateArtifactType(bluePrintRuntimeService, artifactName, artifactType)
}
fun validateNodeTypes(nodeTypes: MutableMap<String, NodeType>) {
- paths.add(BluePrintConstants.PATH_NODE_TYPES)
+ paths.add(BlueprintConstants.PATH_NODE_TYPES)
nodeTypes.forEach { nodeTypeName, nodeType ->
// Validate Single Node Type
bluePrintTypeValidatorService.validateNodeType(bluePrintRuntimeService, nodeTypeName, nodeType)
}
fun validateTopologyTemplate(topologyTemplate: TopologyTemplate) {
- paths.add(BluePrintConstants.PATH_TOPOLOGY_TEMPLATE)
+ paths.add(BlueprintConstants.PATH_TOPOLOGY_TEMPLATE)
bluePrintTypeValidatorService.validateTopologyTemplate(bluePrintRuntimeService, "topologyTemplate", topologyTemplate)
paths.removeAt(paths.lastIndex)
}
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTopologyTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTopologyTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
@Service("default-topology-template-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintTopologyTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
- BluePrintTopologyTemplateValidator {
+open class BlueprintTopologyTemplateValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) :
+ BlueprintTopologyTemplateValidator {
- private val log = LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
+ private val log = LoggerFactory.getLogger(BlueprintServiceTemplateValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, topologyTemplate: TopologyTemplate) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, topologyTemplate: TopologyTemplate) {
log.trace("Validating Topology Template..")
this.bluePrintRuntimeService = bluePrintRuntimeService
topologyTemplate.workflows?.let { validateWorkflows(topologyTemplate.workflows!!) }
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun validateInputs(inputs: MutableMap<String, PropertyDefinition>) {
bluePrintTypeValidatorService.validatePropertyDefinitions(bluePrintRuntimeService, inputs)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun validateNodeTemplates(nodeTemplates: MutableMap<String, NodeTemplate>) {
nodeTemplates.forEach { nodeTemplateName, nodeTemplate ->
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun validateWorkflows(workflows: MutableMap<String, Workflow>) {
workflows.forEach { workflowName, workflow ->
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintAttributeDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintDataTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintPropertyDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintServiceTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTopologyTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintAttributeDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintDataTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintPropertyDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintServiceTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTopologyTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowValidator
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationContext
import org.springframework.stereotype.Service
@Service
-class BluePrintTypeValidatorServiceImpl : BluePrintTypeValidatorService {
+class BlueprintTypeValidatorServiceImpl : BlueprintTypeValidatorService {
companion object {
@Autowired
private lateinit var context: ApplicationContext
- override fun <T : BluePrintValidator<*>> bluePrintValidator(referenceName: String, classType: Class<T>): T? {
+ override fun <T : BlueprintValidator<*>> bluePrintValidator(referenceName: String, classType: Class<T>): T? {
return if (context.containsBean(referenceName)) {
context.getBean(referenceName, classType)
} else {
}
}
- override fun <T : BluePrintValidator<*>> bluePrintValidators(referenceNamePrefix: String, classType: Class<T>): List<T>? {
+ override fun <T : BlueprintValidator<*>> bluePrintValidators(referenceNamePrefix: String, classType: Class<T>): List<T>? {
return context.getBeansOfType(classType)
.filter { it.key.startsWith(referenceNamePrefix) }
.mapNotNull { it.value }
}
- override fun <T : BluePrintValidator<*>> bluePrintValidators(classType: Class<T>): List<T>? {
+ override fun <T : BlueprintValidator<*>> bluePrintValidators(classType: Class<T>): List<T>? {
return context.getBeansOfType(classType).mapNotNull { it.value }
}
- override fun getServiceTemplateValidators(): List<BluePrintServiceTemplateValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintServiceTemplateValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default ServiceTemplate validators")
+ override fun getServiceTemplateValidators(): List<BlueprintServiceTemplateValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintServiceTemplateValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default ServiceTemplate validators")
}
- override fun getDataTypeValidators(): List<BluePrintDataTypeValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintDataTypeValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default DataType validators")
+ override fun getDataTypeValidators(): List<BlueprintDataTypeValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintDataTypeValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default DataType validators")
}
- override fun getArtifactTypeValidators(): List<BluePrintArtifactTypeValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintArtifactTypeValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default ArtifactType validators")
+ override fun getArtifactTypeValidators(): List<BlueprintArtifactTypeValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintArtifactTypeValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default ArtifactType validators")
}
- override fun getArtifactDefinitionsValidators(): List<BluePrintArtifactDefinitionValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintArtifactDefinitionValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default ArtifactDefinition validators")
+ override fun getArtifactDefinitionsValidators(): List<BlueprintArtifactDefinitionValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintArtifactDefinitionValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default ArtifactDefinition validators")
}
- override fun getNodeTypeValidators(): List<BluePrintNodeTypeValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintNodeTypeValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default NodeType validators")
+ override fun getNodeTypeValidators(): List<BlueprintNodeTypeValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintNodeTypeValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default NodeType validators")
}
- override fun getTopologyTemplateValidators(): List<BluePrintTopologyTemplateValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintTopologyTemplateValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default TopologyTemplate validators")
+ override fun getTopologyTemplateValidators(): List<BlueprintTopologyTemplateValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintTopologyTemplateValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default TopologyTemplate validators")
}
- override fun getNodeTemplateValidators(): List<BluePrintNodeTemplateValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintNodeTemplateValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default NodeTemplate validators")
+ override fun getNodeTemplateValidators(): List<BlueprintNodeTemplateValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintNodeTemplateValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default NodeTemplate validators")
}
- override fun getWorkflowValidators(): List<BluePrintWorkflowValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintWorkflowValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default Workflow validators")
+ override fun getWorkflowValidators(): List<BlueprintWorkflowValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintWorkflowValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default Workflow validators")
}
- override fun getPropertyDefinitionValidators(): List<BluePrintPropertyDefinitionValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintPropertyDefinitionValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default PropertyDefinition validators")
+ override fun getPropertyDefinitionValidators(): List<BlueprintPropertyDefinitionValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintPropertyDefinitionValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default PropertyDefinition validators")
}
- override fun getAttributeDefinitionValidators(): List<BluePrintAttributeDefinitionValidator> {
- return bluePrintValidators(PREFIX_DEFAULT, BluePrintAttributeDefinitionValidator::class.java)
- ?: throw BluePrintProcessorException("failed to get default AttributeDefinition validators")
+ override fun getAttributeDefinitionValidators(): List<BlueprintAttributeDefinitionValidator> {
+ return bluePrintValidators(PREFIX_DEFAULT, BlueprintAttributeDefinitionValidator::class.java)
+ ?: throw BlueprintProcessorException("failed to get default AttributeDefinition validators")
}
}
@Configuration
@ComponentScan
-open class BluePrintValidationConfiguration
+open class BlueprintValidationConfiguration
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.validation.utils.PropertyAssignmentValidationUtils
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
@Service("default-workflow-validator")
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintWorkflowValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintWorkflowValidator {
+open class BlueprintWorkflowValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) : BlueprintWorkflowValidator {
- private val log = LoggerFactory.getLogger(BluePrintServiceTemplateValidatorImpl::class.toString())
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ private val log = LoggerFactory.getLogger(BlueprintServiceTemplateValidatorImpl::class.toString())
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
var paths: MutableList<String> = arrayListOf()
- override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, workflowName: String, workflow: Workflow) {
+ override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, workflowName: String, workflow: Workflow) {
log.info("Validating Workflow($workflowName)")
this.bluePrintRuntimeService = bluePrintRuntimeService
paths.add(workflowName)
- paths.joinToString(BluePrintConstants.PATH_DIVIDER)
+ paths.joinToString(BlueprintConstants.PATH_DIVIDER)
// Validate Workflow Inputs
validateInputs(workflow)
paths.add("steps")
workflow.steps?.forEach { stepName, step ->
paths.add(stepName)
- paths.joinToString(BluePrintConstants.PATH_DIVIDER)
+ paths.joinToString(BlueprintConstants.PATH_DIVIDER)
// Validate target
step.target?.let {
val nodeTypeDerivedFrom = bluePrintRuntimeService.bluePrintContext().nodeTemplateNodeType(it).derivedFrom
check(
- nodeTypeDerivedFrom == BluePrintConstants.MODEL_TYPE_NODE_WORKFLOW ||
- nodeTypeDerivedFrom == BluePrintConstants.MODEL_TYPE_NODE_COMPONENT
+ nodeTypeDerivedFrom == BlueprintConstants.MODEL_TYPE_NODE_WORKFLOW ||
+ nodeTypeDerivedFrom == BlueprintConstants.MODEL_TYPE_NODE_COMPONENT
) {
"NodeType(${nodeTemplate.type}) derived from is '$nodeTypeDerivedFrom', Expected " +
- "'${BluePrintConstants.MODEL_TYPE_NODE_WORKFLOW}' or '${BluePrintConstants.MODEL_TYPE_NODE_COMPONENT}'"
+ "'${BlueprintConstants.MODEL_TYPE_NODE_WORKFLOW}' or '${BlueprintConstants.MODEL_TYPE_NODE_COMPONENT}'"
}
} catch (e: Exception) {
- bluePrintRuntimeService.getBluePrintError()
+ bluePrintRuntimeService.getBlueprintError()
.addError(
"Failed to validate Workflow($workflowName)'s step($stepName)'s " +
"definition",
- paths.joinToString(BluePrintConstants.PATH_DIVIDER), e.message!!
+ paths.joinToString(BlueprintConstants.PATH_DIVIDER), e.message!!
)
}
}
package org.onap.ccsdk.cds.controllerblueprints.validation.extension
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.service.ResourceAssignmentValidationServiceImpl
import java.io.File
@Service("artifact-mapping-resource-artifact-definition-validator")
-open class ArtifactMappingResourceValidator(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
- BluePrintArtifactDefinitionValidator {
+open class ArtifactMappingResourceValidator(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) :
+ BlueprintArtifactDefinitionValidator {
private val log = LoggerFactory.getLogger(ArtifactMappingResourceValidator::class.toString())
override fun validate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
artifactDefinition: ArtifactDefinition
) {
package org.onap.ccsdk.cds.controllerblueprints.validation.extension
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
-interface ResourceDefinitionValidator : BluePrintValidator<ResourceDefinition>
+interface ResourceDefinitionValidator : BlueprintValidator<ResourceDefinition>
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class ResourceDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : ResourceDefinitionValidator {
+open class ResourceDefinitionValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) : ResourceDefinitionValidator {
private val log = LoggerFactory.getLogger(ResourceDefinitionValidatorImpl::class.java)
override fun validate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
resourceDefinition: ResourceDefinition
) {
package org.onap.ccsdk.cds.controllerblueprints.validation.utils
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.format
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintExpressionService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintExpressionService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
-open class PropertyAssignmentValidationUtils(private val bluePrintContext: BluePrintContext) {
+open class PropertyAssignmentValidationUtils(private val bluePrintContext: BlueprintContext) {
// Property Definition holds both Definitons and Expression in same construct
open fun validatePropertyDefinitionNAssignments(propertyDefinitions: MutableMap<String, PropertyDefinition>) {
open fun validatePropertyDefinitionNAssignment(propertyName: String, propertyDefinition: PropertyDefinition) {
// Check and Validate if Expression Node
checkNotNull(propertyDefinition.value) {
- throw BluePrintException("couldn't get 'value' property from PropertyDefinition($propertyName)")
+ throw BlueprintException("couldn't get 'value' property from PropertyDefinition($propertyName)")
}
val propertyAssignment = propertyDefinition.value!!
- val expressionData = BluePrintExpressionService.getExpressionData(propertyAssignment)
+ val expressionData = BlueprintExpressionService.getExpressionData(propertyAssignment)
if (!expressionData.isExpression) {
checkPropertyValue(propertyName, propertyDefinition, propertyAssignment)
}
) {
properties.forEach { propertyName, propertyAssignment ->
val propertyDefinition: PropertyDefinition = nodeTypeProperties[propertyName]
- ?: throw BluePrintException("validatePropertyAssignments failed to get definition for the property ($propertyName)")
+ ?: throw BlueprintException("validatePropertyAssignments failed to get definition for the property ($propertyName)")
validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)
}
propertyAssignment: JsonNode
) {
// Check and Validate if Expression Node
- val expressionData = BluePrintExpressionService.getExpressionData(propertyAssignment)
+ val expressionData = BlueprintExpressionService.getExpressionData(propertyAssignment)
if (!expressionData.isExpression) {
checkPropertyValue(propertyName, propertyDefinition, propertyAssignment)
}
val propertyType = propertyDefinition.type
val isValid: Boolean
- if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {
+ if (BlueprintTypes.validPrimitiveTypes().contains(propertyType)) {
isValid = JacksonUtils.checkJsonNodeValueOfPrimitiveType(propertyType, propertyAssignment)
- } else if (BluePrintTypes.validComplexTypes().contains(propertyType)) {
+ } else if (BlueprintTypes.validComplexTypes().contains(propertyType)) {
isValid = true
- } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {
+ } else if (BlueprintTypes.validCollectionTypes().contains(propertyType)) {
val entrySchemaType = propertyDefinition.entrySchema?.type
- ?: throw BluePrintException(format("Failed to get EntrySchema type for the collection property ({})", propertyName))
+ ?: throw BlueprintException(format("Failed to get EntrySchema type for the collection property ({})", propertyName))
- if (!BluePrintTypes.validPropertyTypes().contains(entrySchemaType)) {
+ if (!BlueprintTypes.validPropertyTypes().contains(entrySchemaType)) {
checkPropertyDataType(entrySchemaType, propertyName)
}
isValid = JacksonUtils.checkJsonNodeValueOfCollectionType(propertyType, propertyAssignment)
}
check(isValid) {
- throw BluePrintException("property($propertyName) defined of type($propertyType) is not compatible with the value ($propertyAssignment)")
+ throw BlueprintException("property($propertyName) defined of type($propertyType) is not compatible with the value ($propertyAssignment)")
}
}
open fun checkPropertyDataType(dataTypeName: String, propertyName: String) {
val dataType = bluePrintContext.serviceTemplate.dataTypes?.get(dataTypeName)
- ?: throw BluePrintException("DataType ($dataTypeName) for the property ($propertyName) not found")
+ ?: throw BlueprintException("DataType ($dataTypeName) for the property ($propertyName) not found")
checkValidDataTypeDerivedFrom(propertyName, dataType.derivedFrom)
}
open fun checkValidDataTypeDerivedFrom(dataTypeName: String, derivedFrom: String) {
- check(BluePrintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
- throw BluePrintException("Failed to get DataType($dataTypeName)'s derivedFrom($derivedFrom) definition ")
+ check(BlueprintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {
+ throw BlueprintException("Failed to get DataType($dataTypeName)'s derivedFrom($derivedFrom) definition ")
}
}
}
import io.mockk.mockk
import kotlinx.coroutines.runBlocking
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.Step
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.validation.extension.ResourceDefinitionValidator
import kotlin.test.assertEquals
import kotlin.test.assertTrue
-class BluePrintDesignTimeValidatorServiceTest {
+class BlueprintDesignTimeValidatorServiceTest {
private val blueprintBasePath = "./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
- private val bluePrintRuntime = BluePrintMetadataUtils.bluePrintRuntime("1234", blueprintBasePath)
- private val mockBluePrintTypeValidatorService = MockBluePrintTypeValidatorService()
+ private val bluePrintRuntime = BlueprintMetadataUtils.bluePrintRuntime("1234", blueprintBasePath)
+ private val mockBlueprintTypeValidatorService = MockBlueprintTypeValidatorService()
private val resourceDefinitionValidator = mockk<ResourceDefinitionValidator>()
- private val defaultBluePrintValidatorService =
- BluePrintDesignTimeValidatorService(mockBluePrintTypeValidatorService, resourceDefinitionValidator)
- private val workflowValidator = BluePrintWorkflowValidatorImpl(mockBluePrintTypeValidatorService)
+ private val defaultBlueprintValidatorService =
+ BlueprintDesignTimeValidatorService(mockBlueprintTypeValidatorService, resourceDefinitionValidator)
+ private val workflowValidator = BlueprintWorkflowValidatorImpl(mockBlueprintTypeValidatorService)
@Test
fun testValidateOfType() {
runBlocking {
every { resourceDefinitionValidator.validate(bluePrintRuntime, any(), any()) } returns Unit
- val valid = defaultBluePrintValidatorService.validateBluePrints(bluePrintRuntime)
+ val valid = defaultBlueprintValidatorService.validateBlueprints(bluePrintRuntime)
assertTrue(valid, "failed in blueprint Validation")
}
}
workflow.steps = mutableMapOf("test" to step)
workflowValidator.validate(bluePrintRuntime, workflowName, workflow)
- assertEquals(1, bluePrintRuntime.getBluePrintError().errors.size)
+ assertEquals(1, bluePrintRuntime.getBlueprintError().errors.size)
assertEquals(
"Failed to validate Workflow(resource-assignment)'s step(test)'s definition : resource-assignment/steps/test : could't get node template for the name(TestCaseFailNoNodeTemplate)",
- bluePrintRuntime.getBluePrintError().errors[0]
+ bluePrintRuntime.getBlueprintError().errors[0]
)
}
val nodeType = mockk<NodeType>()
every { nodeType.derivedFrom } returns "tosca.nodes.TEST"
- val blueprintContext = mockk<BluePrintContext>()
+ val blueprintContext = mockk<BlueprintContext>()
every { blueprintContext.nodeTemplateByName(nodeTemplateName) } returns nodeTemplate
every { blueprintContext.nodeTemplateNodeType(nodeTemplateName) } returns nodeType
- val bluePrintRuntime = mockk<DefaultBluePrintRuntimeService>("1234")
+ val bluePrintRuntime = mockk<DefaultBlueprintRuntimeService>("1234")
- every { bluePrintRuntime.getBluePrintError() } returns BluePrintError()
+ every { bluePrintRuntime.getBlueprintError() } returns BlueprintError()
every { bluePrintRuntime.bluePrintContext() } returns blueprintContext
val step = Step()
workflow.steps = mutableMapOf("test" to step)
workflowValidator.validate(bluePrintRuntime, workflowName, workflow)
- assertEquals(1, bluePrintRuntime.getBluePrintError().errors.size)
+ assertEquals(1, bluePrintRuntime.getBlueprintError().errors.size)
assertEquals(
"Failed to validate Workflow(resource-assignment)'s step(test)'s definition : " +
"resource-assignment/steps/test : NodeType(TestNodeType) derived from is 'tosca.nodes.TEST', " +
"Expected 'tosca.nodes.Workflow' or 'tosca.nodes.Component'",
- bluePrintRuntime.getBluePrintError().errors[0]
+ bluePrintRuntime.getBlueprintError().errors[0]
)
}
package org.onap.ccsdk.cds.controllerblueprints.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintAttributeDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintDataTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintPropertyDefinitionValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintServiceTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTopologyTemplateValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowValidator
-
-class MockBluePrintTypeValidatorService : BluePrintTypeValidatorService {
-
- override fun <T : BluePrintValidator<*>> bluePrintValidator(referenceName: String, classType: Class<T>): T? {
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintAttributeDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintDataTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTypeValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintPropertyDefinitionValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintServiceTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTopologyTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowValidator
+
+class MockBlueprintTypeValidatorService : BlueprintTypeValidatorService {
+
+ override fun <T : BlueprintValidator<*>> bluePrintValidator(referenceName: String, classType: Class<T>): T? {
return null
}
- override fun <T : BluePrintValidator<*>> bluePrintValidators(referenceNamePrefix: String, classType: Class<T>): List<T>? {
+ override fun <T : BlueprintValidator<*>> bluePrintValidators(referenceNamePrefix: String, classType: Class<T>): List<T>? {
return null
}
- override fun <T : BluePrintValidator<*>> bluePrintValidators(classType: Class<T>): List<T>? {
+ override fun <T : BlueprintValidator<*>> bluePrintValidators(classType: Class<T>): List<T>? {
return null
}
- override fun getServiceTemplateValidators(): List<BluePrintServiceTemplateValidator> {
- return listOf(BluePrintServiceTemplateValidatorImpl(this))
+ override fun getServiceTemplateValidators(): List<BlueprintServiceTemplateValidator> {
+ return listOf(BlueprintServiceTemplateValidatorImpl(this))
}
- override fun getDataTypeValidators(): List<BluePrintDataTypeValidator> {
- return listOf(BluePrintDataTypeValidatorImpl(this))
+ override fun getDataTypeValidators(): List<BlueprintDataTypeValidator> {
+ return listOf(BlueprintDataTypeValidatorImpl(this))
}
- override fun getArtifactTypeValidators(): List<BluePrintArtifactTypeValidator> {
- return listOf(BluePrintArtifactTypeValidatorImpl(this))
+ override fun getArtifactTypeValidators(): List<BlueprintArtifactTypeValidator> {
+ return listOf(BlueprintArtifactTypeValidatorImpl(this))
}
- override fun getArtifactDefinitionsValidators(): List<BluePrintArtifactDefinitionValidator> {
- return listOf(BluePrintArtifactDefinitionValidatorImpl(this))
+ override fun getArtifactDefinitionsValidators(): List<BlueprintArtifactDefinitionValidator> {
+ return listOf(BlueprintArtifactDefinitionValidatorImpl(this))
}
- override fun getNodeTypeValidators(): List<BluePrintNodeTypeValidator> {
- return listOf(BluePrintNodeTypeValidatorImpl(this))
+ override fun getNodeTypeValidators(): List<BlueprintNodeTypeValidator> {
+ return listOf(BlueprintNodeTypeValidatorImpl(this))
}
- override fun getTopologyTemplateValidators(): List<BluePrintTopologyTemplateValidator> {
- return listOf(BluePrintTopologyTemplateValidatorImpl(this))
+ override fun getTopologyTemplateValidators(): List<BlueprintTopologyTemplateValidator> {
+ return listOf(BlueprintTopologyTemplateValidatorImpl(this))
}
- override fun getNodeTemplateValidators(): List<BluePrintNodeTemplateValidator> {
- return listOf(BluePrintNodeTemplateValidatorImpl(this))
+ override fun getNodeTemplateValidators(): List<BlueprintNodeTemplateValidator> {
+ return listOf(BlueprintNodeTemplateValidatorImpl(this))
}
- override fun getWorkflowValidators(): List<BluePrintWorkflowValidator> {
- return listOf(BluePrintWorkflowValidatorImpl(this))
+ override fun getWorkflowValidators(): List<BlueprintWorkflowValidator> {
+ return listOf(BlueprintWorkflowValidatorImpl(this))
}
- override fun getPropertyDefinitionValidators(): List<BluePrintPropertyDefinitionValidator> {
- return listOf(BluePrintPropertyDefinitionValidatorImpl(this))
+ override fun getPropertyDefinitionValidators(): List<BlueprintPropertyDefinitionValidator> {
+ return listOf(BlueprintPropertyDefinitionValidatorImpl(this))
}
- override fun getAttributeDefinitionValidators(): List<BluePrintAttributeDefinitionValidator> {
- return listOf(BluePrintAttributeDefinitionValidatorImpl(this))
+ override fun getAttributeDefinitionValidators(): List<BlueprintAttributeDefinitionValidator> {
+ return listOf(BlueprintAttributeDefinitionValidatorImpl(this))
}
}
package org.onap.ccsdk.cds.controllerblueprints.resource.dict.factory
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.format
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceSourceMapping
fun getRegisterSourceMapping(sourceInstance: String): String {
return resourceSourceMappings[sourceInstance]
- ?: throw BluePrintException(format("failed to get source({}) mapping", sourceInstance))
+ ?: throw BlueprintException(format("failed to get source({}) mapping", sourceInstance))
}
fun getRegisterSourceMapping(): ResourceSourceMapping {
import org.apache.commons.collections.CollectionUtils
import org.apache.commons.lang3.StringUtils
import org.apache.commons.lang3.text.StrBuilder
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.TopologicalSortingUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.slf4j.LoggerFactory
*/
interface ResourceAssignmentValidationService : Serializable {
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun validate(resourceAssignments: List<ResourceAssignment>): Boolean
}
validateTemplateNDictionaryKeys(resourceAssignments)
validateCyclicDependency(resourceAssignments)
if (StringUtils.isNotBlank(validationMessage)) {
- throw BluePrintException("Resource Assignment Validation Failure")
+ throw BlueprintException("Resource Assignment Validation Failure")
}
} catch (e: Exception) {
- throw BluePrintException("Resource Assignment Validation :" + validationMessage.toString(), e)
+ throw BlueprintException("Resource Assignment Validation :" + validationMessage.toString(), e)
}
return true
}
}
if (StringUtils.isNotBlank(validationMessage)) {
- throw BluePrintException("Resource Assignment Validation Failure")
+ throw BlueprintException("Resource Assignment Validation Failure")
}
}
package org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils
import org.apache.commons.collections.CollectionUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asListOfString
import org.onap.ccsdk.cds.controllerblueprints.core.utils.TopologicalSortingUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
} else if (CollectionUtils.isNotEmpty(resourceAssignment.dependencies)) {
for (dependency in resourceAssignment.dependencies!!) {
val ra = resourceAssignmentMap[dependency]
- ?: throw BluePrintProcessorException(
+ ?: throw BlueprintProcessorException(
"Couldn't get Resource Assignment dependency " +
"Key($dependency)"
)
import com.fasterxml.jackson.databind.node.NullNode
import org.apache.commons.collections.MapUtils
import org.apache.commons.lang3.StringUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintFileUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintFileUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
data.fields().forEach { field ->
val valueNode: JsonNode = data.at("/".plus(field.key)) ?: NullNode.getInstance()
- val path = BluePrintConstants.PATH_INPUTS.plus(BluePrintConstants.PATH_DIVIDER).plus(field.key)
+ val path = BlueprintConstants.PATH_INPUTS.plus(BlueprintConstants.PATH_DIVIDER).plus(field.key)
log.trace("setting path ({}), values ({})", path, valueNode)
context[path] = valueNode
}
fun getResourceAssignmentFromFile(filePath: String): List<ResourceAssignment> {
return JacksonUtils.getListFromFile(filePath, ResourceAssignment::class.java)
- ?: throw BluePrintProcessorException("couldn't get ResourceAssignment definitions for the file($filePath)")
+ ?: throw BlueprintProcessorException("couldn't get ResourceAssignment definitions for the file($filePath)")
}
fun writeResourceDefinitionTypes(basePath: String, resourceDefinitions: List<ResourceDefinition>) {
}
fun writeResourceDefinitionTypes(basePath: String, resourceDefinitionMap: Map<String, ResourceDefinition>) {
- val typePath = basePath.plus(File.separator).plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR)
+ val typePath = basePath.plus(File.separator).plus(BlueprintConstants.TOSCA_DEFINITIONS_DIR)
.plus(File.separator).plus("${ResourceDictionaryConstants.PATH_RESOURCE_DEFINITION_TYPE}.json")
val resourceDefinitionContent = JacksonUtils.getJson(resourceDefinitionMap.toSortedMap(), true)
- BluePrintFileUtils.writeDefinitionFile(typePath, resourceDefinitionContent)
+ BlueprintFileUtils.writeDefinitionFile(typePath, resourceDefinitionContent)
}
}
import org.junit.Assert
import org.junit.Before
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils.ResourceDictionaryTestUtils
Assert.assertTrue("Failed to Validate", result)
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testValidateDuplicate() {
log.info(" **************** testValidateDuplicate *****************")
val assignments = JacksonUtils.getListFromClassPathFile("validation/duplicate.json", ResourceAssignment::class.java)
resourceAssignmentValidator.validate(assignments!!)
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun testValidateCyclic() {
log.info(" **************** testValidateCyclic *****************")
val assignments = JacksonUtils.getListFromClassPathFile("validation/cyclic.json", ResourceAssignment::class.java)
import com.fasterxml.jackson.databind.JsonNode;
import org.junit.Assert;
import org.junit.Test;
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants;
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants;
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate;
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils;
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment;
JsonNode data = JacksonUtils.Companion.jsonNodeFromClassPathFile("data/resource-assignment-input.json");
Map<String, Object> context = new HashMap<>();
ResourceDictionaryUtils.assignInputs(data, context);
- String path = BluePrintConstants.PATH_INPUTS.concat(BluePrintConstants.PATH_DIVIDER).concat("mapValue");
+ String path = BlueprintConstants.PATH_INPUTS.concat(BlueprintConstants.PATH_DIVIDER).concat("mapValue");
log.info("populated context {}", context);
Assert.assertTrue(String.format("failed to get variable : %s", path), context.containsKey(path));
package org.onap.ccsdk.cds.blueprintsprocessor.db
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.BluePrintDBLibPropertyService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.BlueprintDBLibPropertyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
@Import(
- BluePrintPropertyConfiguration::class,
- BluePrintPropertiesService::class,
- BluePrintCoreConfiguration::class
+ BlueprintPropertyConfiguration::class,
+ BlueprintPropertiesService::class,
+ BlueprintCoreConfiguration::class
)
@EnableConfigurationProperties
-open class BluePrintDBLibConfiguration(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+open class BlueprintDBLibConfiguration(private var bluePrintPropertiesService: BlueprintPropertiesService) {
@Bean("primary-database-properties")
open fun getPrimaryProperties(): PrimaryDataSourceProperties {
/**
* Exposed Dependency Service by this SSH Lib Module
*/
-fun BluePrintDependencyService.dbLibPropertyService(): BluePrintDBLibPropertyService =
- instance(BluePrintDBLibPropertyService::class)
+fun BlueprintDependencyService.dbLibPropertyService(): BlueprintDBLibPropertyService =
+ instance(BlueprintDBLibPropertyService::class)
-fun BluePrintDependencyService.primaryDBLibGenericService(): BluePrintDBLibGenericService =
+fun BlueprintDependencyService.primaryDBLibGenericService(): BlueprintDBLibGenericService =
instance(PrimaryDBLibGenericService::class)
class DBLibConstants {
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
-interface BluePrintDBLibGenericService {
+interface BlueprintDBLibGenericService {
fun namedParameterJdbcTemplate(): NamedParameterJdbcTemplate
}
abstract class AbstractDBLibGenericService(private val namedParameterJdbcTemplate: NamedParameterJdbcTemplate) :
- BluePrintDBLibGenericService {
+ BlueprintDBLibGenericService {
override fun namedParameterJdbcTemplate(): NamedParameterJdbcTemplate {
return namedParameterJdbcTemplate
package org.onap.ccsdk.cds.blueprintsprocessor.db
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
/** Relationships Types DSL for Database Producer */
fun ServiceTemplateBuilder.relationshipTypeConnectsToDb() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToDb()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToDb()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToDb(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToDb(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship connects to through Database."
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
class DbRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB, description
) {
fun mariaDb(block: DbMariaDataSourcePropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.mariaDbProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.mariaDbProperties(block))
}
fun mySqlDb(block: DbMySqlDataSourcePropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.mySqlDbProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.mySqlDbProperties(block))
}
}
-fun BluePrintTypes.mariaDbProperties(block: DbMariaDataSourcePropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.mariaDbProperties(block: DbMariaDataSourcePropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = DbMariaDataSourcePropertiesAssignmentBuilder().apply(block).build()
assignments[DBDataSourceProperties::type.name] = DBLibConstants.MARIA_DB.asJsonPrimitive()
return assignments.asJsonNode()
}
-fun BluePrintTypes.mySqlDbProperties(block: DbMySqlDataSourcePropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.mySqlDbProperties(block: DbMySqlDataSourcePropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = DbMySqlDataSourcePropertiesAssignmentBuilder().apply(block).build()
assignments[DBDataSourceProperties::type.name] = DBLibConstants.MYSQL_DB.asJsonPrimitive()
return assignments.asJsonNode()
package org.onap.ccsdk.cds.blueprintsprocessor.db.primary
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibGenericService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibGenericService
import org.onap.ccsdk.cds.blueprintsprocessor.db.DBDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.DBLibConstants.Companion.MARIA_DB
import org.onap.ccsdk.cds.blueprintsprocessor.db.DBLibConstants.Companion.MYSQL_DB
import org.onap.ccsdk.cds.blueprintsprocessor.db.DBLibConstants.Companion.PROCESSOR_DB
import org.onap.ccsdk.cds.blueprintsprocessor.db.MariaDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.MySqlDataSourceProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.stereotype.Service
@Service
-class BluePrintDBLibPropertyService(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+class BlueprintDBLibPropertyService(private var bluePrintPropertiesService: BlueprintPropertiesService) {
- fun JdbcTemplate(jsonNode: JsonNode): BluePrintDBLibGenericService =
+ fun JdbcTemplate(jsonNode: JsonNode): BlueprintDBLibGenericService =
blueprintDBDataSourceService(dBDataSourceProperties(jsonNode))
- fun JdbcTemplate(selector: String): BluePrintDBLibGenericService =
+ fun JdbcTemplate(selector: String): BlueprintDBLibGenericService =
blueprintDBDataSourceService(dBDataSourceProperties("blueprintsprocessor.db.$selector"))
private fun dBDataSourceProperties(jsonNode: JsonNode): DBDataSourceProperties =
MYSQL_DB -> JacksonUtils.readValue(jsonNode, MySqlDataSourceProperties::class.java)
MARIA_DB -> JacksonUtils.readValue(jsonNode, MariaDataSourceProperties::class.java)
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"DB type ($type) is not supported. Valid types: $MARIA_DB, $MYSQL_DB"
)
}
MARIA_DB, PROCESSOR_DB -> mariaDBConnectionProperties(prefix)
MYSQL_DB -> mySqlDBConnectionProperties(prefix)
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"DB type ($it) is not supported. Valid types: $MARIA_DB, $MYSQL_DB, $PROCESSOR_DB"
)
}
}
}
- private fun blueprintDBDataSourceService(dBConnetionProperties: DBDataSourceProperties): BluePrintDBLibGenericService =
+ private fun blueprintDBDataSourceService(dBConnetionProperties: DBDataSourceProperties): BlueprintDBLibGenericService =
when (dBConnetionProperties) {
is MariaDataSourceProperties -> MariaDatabaseConfiguration(dBConnetionProperties)
is MySqlDataSourceProperties -> MySqlDatabaseConfiguration(dBConnetionProperties)
- else -> throw BluePrintProcessorException(
+ else -> throw BlueprintProcessorException(
"Failed to create db configuration for ${dBConnetionProperties.url}"
)
}
package org.onap.ccsdk.cds.blueprintsprocessor.db.primary
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibGenericService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibGenericService
import org.onap.ccsdk.cds.blueprintsprocessor.db.MariaDataSourceProperties
import org.slf4j.LoggerFactory
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
import org.springframework.jdbc.datasource.DriverManagerDataSource
import javax.sql.DataSource
-class MariaDatabaseConfiguration(private val mariaDataSourceProperties: MariaDataSourceProperties) : BluePrintDBLibGenericService {
+class MariaDatabaseConfiguration(private val mariaDataSourceProperties: MariaDataSourceProperties) : BlueprintDBLibGenericService {
val log = LoggerFactory.getLogger(MariaDatabaseConfiguration::class.java)!!
package org.onap.ccsdk.cds.blueprintsprocessor.db.primary
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibGenericService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibGenericService
import org.onap.ccsdk.cds.blueprintsprocessor.db.MySqlDataSourceProperties
import org.slf4j.LoggerFactory
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
import org.springframework.jdbc.datasource.DriverManagerDataSource
import javax.sql.DataSource
-class MySqlDatabaseConfiguration(private val mySqlDataSourceProperties: MySqlDataSourceProperties) : BluePrintDBLibGenericService {
+class MySqlDatabaseConfiguration(private val mySqlDataSourceProperties: MySqlDataSourceProperties) : BlueprintDBLibGenericService {
override fun namedParameterJdbcTemplate(): NamedParameterJdbcTemplate {
return mySqlNamedParameterJdbcTemplate(mySqlDataSource())
package org.onap.ccsdk.cds.blueprintsprocessor.db.primary.service
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
import org.onap.ccsdk.cds.controllerblueprints.core.deCompress
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidatorService
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.slf4j.LoggerFactory
import java.io.File
import java.nio.file.Path
@MappedSuperclass
abstract class BlueprintCatalogServiceImpl(
- private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
- private val blueprintValidator: BluePrintValidatorService
-) : BluePrintCatalogService {
+ private val bluePrintLoadConfiguration: BlueprintLoadConfiguration,
+ private val blueprintValidator: BlueprintValidatorService
+) : BlueprintCatalogService {
private val log = LoggerFactory.getLogger(BlueprintCatalogServiceImpl::class.java)!!
workingDir = blueprintFile.absolutePath
archiveFile = normalizedFile(bluePrintLoadConfiguration.blueprintArchivePath, processingId, "cba.zip")
- if (!BluePrintArchiveUtils.compress(blueprintFile, archiveFile)) {
- throw BluePrintException("Fail to compress blueprint")
+ if (!BlueprintArchiveUtils.compress(blueprintFile, archiveFile)) {
+ throw BlueprintException("Fail to compress blueprint")
}
} else {
// Compressed File
blueprintFile.deCompress(workingDir)
}
- var valid = BluePrintConstants.FLAG_N
+ var valid = BlueprintConstants.FLAG_N
if (validate) {
- blueprintValidator.validateBluePrints(workingDir!!)
- valid = BluePrintConstants.FLAG_Y
+ blueprintValidator.validateBlueprints(workingDir!!)
+ valid = BlueprintConstants.FLAG_Y
}
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(processingId, workingDir!!)
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(processingId, workingDir!!)
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- metadata[BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID] = processingId
- metadata[BluePrintConstants.PROPERTY_BLUEPRINT_VALID] = valid
+ metadata[BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID] = processingId
+ metadata[BlueprintConstants.PROPERTY_BLUEPRINT_VALID] = valid
save(metadata, archiveFile)
name, version,
extract
)
- ?: throw BluePrintException("Could not find blueprint $name:$version from database")
+ ?: throw BlueprintException("Could not find blueprint $name:$version from database")
override suspend fun deleteFromDatabase(name: String, version: String) = delete(name, version)
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.domain.BlueprintModel
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.domain.BlueprintModelContent
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.repository.BlueprintModelRepository
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.common.ApplicationConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
import org.onap.ccsdk.cds.controllerblueprints.core.data.ErrorCode
import org.onap.ccsdk.cds.controllerblueprints.core.deCompress
import org.onap.ccsdk.cds.controllerblueprints.core.deleteNBDir
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidatorService
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
import org.onap.ccsdk.cds.controllerblueprints.core.reCreateNBDirs
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintCompileCache
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintFileUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintCompileCache
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintFileUtils
import org.slf4j.LoggerFactory
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.stereotype.Service
*/
@Service("blueprintsProcessorCatalogService")
class BlueprintProcessorCatalogServiceImpl(
- bluePrintRuntimeValidatorService: BluePrintValidatorService,
- private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+ bluePrintRuntimeValidatorService: BlueprintValidatorService,
+ private val bluePrintLoadConfiguration: BlueprintLoadConfiguration,
private val blueprintModelRepository: BlueprintModelRepository
) :
BlueprintCatalogServiceImpl(bluePrintLoadConfiguration, bluePrintRuntimeValidatorService) {
override suspend fun delete(name: String, version: String) {
// Clean blueprint script cache
- val cacheKey = BluePrintFileUtils
+ val cacheKey = BlueprintFileUtils
.compileCacheKey(normalizedPathName(bluePrintLoadConfiguration.blueprintDeployPath, name, version))
cleanClassLoader(cacheKey)
log.info("removed cba file name($name), version($version) from cache")
}
check(deployFile.exists() && deployFile.list().isNotEmpty()) {
- throw BluePrintProcessorException("file check failed")
+ throw BlueprintProcessorException("file check failed")
}
} catch (e: Exception) {
deleteNBDir(deployFile.absolutePath)
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"failed to get get cba file name($name), version($version) from db" +
" : ${e.message}"
)
}
override suspend fun save(metadata: MutableMap<String, String>, archiveFile: File) {
- val artifactName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]
- val artifactVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]
+ val artifactName = metadata[BlueprintConstants.METADATA_TEMPLATE_NAME]
+ val artifactVersion = metadata[BlueprintConstants.METADATA_TEMPLATE_VERSION]
check(archiveFile.isFile && !archiveFile.isDirectory) {
- throw BluePrintException("Not a valid Archive file(${archiveFile.absolutePath})")
+ throw BlueprintException("Not a valid Archive file(${archiveFile.absolutePath})")
}
blueprintModelRepository.findByArtifactNameAndArtifactVersion(artifactName!!, artifactVersion!!)?.let {
val deployFile =
normalizedPathName(bluePrintLoadConfiguration.blueprintDeployPath, artifactName, artifactVersion)
- val cacheKey = BluePrintFileUtils.compileCacheKey(deployFile)
+ val cacheKey = BlueprintFileUtils.compileCacheKey(deployFile)
cleanClassLoader(cacheKey)
deleteNBDir(deployFile).let {
}
val blueprintModel = BlueprintModel()
- blueprintModel.id = metadata[BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID]
+ blueprintModel.id = metadata[BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID]
blueprintModel.artifactType = ApplicationConstants.ASDC_ARTIFACT_TYPE_SDNC_MODEL
- blueprintModel.published = metadata[BluePrintConstants.PROPERTY_BLUEPRINT_VALID]
- ?: BluePrintConstants.FLAG_N
+ blueprintModel.published = metadata[BlueprintConstants.PROPERTY_BLUEPRINT_VALID]
+ ?: BlueprintConstants.FLAG_N
blueprintModel.artifactName = artifactName
blueprintModel.artifactVersion = artifactVersion
- blueprintModel.updatedBy = metadata[BluePrintConstants.METADATA_TEMPLATE_AUTHOR]!!
- blueprintModel.tags = metadata[BluePrintConstants.METADATA_TEMPLATE_TAGS]!!
+ blueprintModel.updatedBy = metadata[BlueprintConstants.METADATA_TEMPLATE_AUTHOR]!!
+ blueprintModel.tags = metadata[BlueprintConstants.METADATA_TEMPLATE_TAGS]!!
val description =
- if (null != metadata[BluePrintConstants.METADATA_TEMPLATE_DESCRIPTION]) metadata[BluePrintConstants.METADATA_TEMPLATE_DESCRIPTION] else ""
+ if (null != metadata[BlueprintConstants.METADATA_TEMPLATE_DESCRIPTION]) metadata[BlueprintConstants.METADATA_TEMPLATE_DESCRIPTION] else ""
blueprintModel.artifactDescription = description
val blueprintModelContent = BlueprintModelContent()
- blueprintModelContent.id = metadata[BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID]
+ blueprintModelContent.id = metadata[BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID]
blueprintModelContent.contentType = "CBA_ZIP"
blueprintModelContent.name = "$artifactName:$artifactVersion"
blueprintModelContent.description = "$artifactName:$artifactVersion CBA Zip Content"
try {
blueprintModelRepository.saveAndFlush(blueprintModel)
} catch (ex: DataIntegrityViolationException) {
- throw BluePrintException(
+ throw BlueprintException(
ErrorCode.CONFLICT_ADDING_RESOURCE.value,
"The blueprint entry " +
"is already exist in database: ${ex.message}",
}
private suspend fun cleanClassLoader(cacheKey: String) {
- val clusterService = BluePrintDependencyService.optionalClusterService()
+ val clusterService = BlueprintDependencyService.optionalClusterService()
if (null == clusterService)
- BluePrintCompileCache.cleanClassLoader(cacheKey)
+ BlueprintCompileCache.cleanClassLoader(cacheKey)
else {
log.info("Sending ClusterMessage: Clean Classloader Cache")
clusterService.sendMessage(BlueprintClusterTopic.BLUEPRINT_CLEAN_COMPILER_CACHE, cacheKey)
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.mock.MockBlueprintProcessorCatalogServiceImpl
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.service.BlueprintCatalogServiceImpl
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.service.BlueprintProcessorCatalogServiceImpl
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.compress
import org.onap.ccsdk.cds.controllerblueprints.core.deleteDir
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.context.annotation.ComponentScan
@ComponentScan(basePackages = ["org.onap.ccsdk.cds.blueprintsprocessor"])
@ContextConfiguration(
classes = [
- BlueprintProcessorCatalogServiceImpl::class, BluePrintCoreConfiguration::class,
+ BlueprintProcessorCatalogServiceImpl::class, BlueprintCoreConfiguration::class,
MockBlueprintProcessorCatalogServiceImpl::class
]
)
lateinit var blueprintsProcessorCatalogService: BlueprintCatalogServiceImpl
@Autowired
- lateinit var blueprintCoreConfiguration: BluePrintCoreConfiguration
+ lateinit var blueprintCoreConfiguration: BlueprintCoreConfiguration
- private lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ private lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
private val blueprintId = "1234"
normalizedFile("./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration")
.compress(normalizedFile("./target/blueprints/generated-cba.zip"))
- bluePrintRuntimeService = BluePrintMetadataUtils.bluePrintRuntime(
+ bluePrintRuntimeService = BlueprintMetadataUtils.bluePrintRuntime(
blueprintId,
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
val file = normalizedFile("./target/blueprints/generated-cba.zip")
assertTrue(file.exists(), "couldnt get file ${file.absolutePath}")
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- metadata[BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID] = blueprintId
+ metadata[BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID] = blueprintId
blueprintsProcessorCatalogService.save(metadata, file)
}
val file = normalizedFile("./target/blueprints/generated-cba.zip")
assertTrue(file.exists(), "couldnt get file ${file.absolutePath}")
val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
- metadata[BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID] = blueprintId
+ metadata[BlueprintConstants.PROPERTY_BLUEPRINT_PROCESS_ID] = blueprintId
blueprintsProcessorCatalogService.save(metadata, file)
blueprintsProcessorCatalogService.get("baseconfiguration", "1.0.0", true)
package org.onap.ccsdk.cds.blueprintsprocessor.db
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.relationshipTypeConnectsTo
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
import kotlin.test.assertEquals
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_DB}"
)
}
}
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = ["org.onap.ccsdk.cds.blueprintsprocessor.db.primary"],
entityManagerFactoryRef = "primaryEntityManager",
import io.mockk.coEvery
import io.mockk.mockk
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
open class MockBlueprintProcessorCatalogServiceImpl {
@Bean(name = ["bluePrintRuntimeValidatorService"])
- open fun bluePrintRuntimeValidatorService(): BluePrintValidatorService {
- val bluePrintValidatorService = mockk<BluePrintValidatorService>()
- coEvery { bluePrintValidatorService.validateBluePrints(any<String>()) } returns true
- coEvery { bluePrintValidatorService.validateBluePrints(any<BluePrintRuntimeService<*>>()) } returns true
+ open fun bluePrintRuntimeValidatorService(): BlueprintValidatorService {
+ val bluePrintValidatorService = mockk<BlueprintValidatorService>()
+ coEvery { bluePrintValidatorService.validateBlueprints(any<String>()) } returns true
+ coEvery { bluePrintValidatorService.validateBlueprints(any<BlueprintRuntimeService<*>>()) } returns true
return bluePrintValidatorService
}
}
class AafAuthDmaapClientService(
private val clientProps: AafAuthDmaapClientProperties
) :
- BluePrintDmaapClientService {
+ BlueprintDmaapClientService {
/**
* The constructed DMAAP client.
* properties provided. This abstraction also provides a mechanism to send
* messages with the given partition in a session and closing the same.
*/
-interface BluePrintDmaapClientService {
+interface BlueprintDmaapClientService {
/**
* Static variable for logging.
companion object {
var log = LoggerFactory.getLogger(
- BluePrintDmaapClientService::class.java
+ BlueprintDmaapClientService::class.java
)!!
}
@Configuration
@ComponentScan
@EnableConfigurationProperties
-open class BluePrintDmaapLibConfiguration
+open class BlueprintDmaapLibConfiguration
/**
* Util constants required for DMAAP library to use.
package org.onap.ccsdk.cds.blueprintsprocessor.dmaap
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.dmaap.DmaapLibConstants.Companion.SERVICE_BLUEPRINT_DMAAP_LIB_PROPERTY
import org.onap.ccsdk.cds.blueprintsprocessor.dmaap.DmaapLibConstants.Companion.TYPE_HTTP_AAF_AUTH
import org.onap.ccsdk.cds.blueprintsprocessor.dmaap.DmaapLibConstants.Companion.TYPE_HTTP_NO_AUTH
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
@Service(SERVICE_BLUEPRINT_DMAAP_LIB_PROPERTY)
@Configuration
@PropertySources(PropertySource("classpath:event.properties"))
-open class BluePrintDmaapLibPropertyService(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+open class BlueprintDmaapLibPropertyService(private var bluePrintPropertiesService: BlueprintPropertiesService) {
/**
* Static variable for logging.
companion object {
var log = LoggerFactory.getLogger(
- BluePrintDmaapLibPropertyService::class.java
+ BlueprintDmaapLibPropertyService::class.java
)!!
}
* node.
*/
fun blueprintDmaapClientService(jsonNode: JsonNode):
- BluePrintDmaapClientService {
+ BlueprintDmaapClientService {
val dmaapProps = dmaapClientProperties(jsonNode)
return blueprintDmaapClientService(dmaapProps)
}
* selector string.
*/
fun blueprintDmaapClientService(selector: String):
- BluePrintDmaapClientService {
+ BlueprintDmaapClientService {
val prefix = "blueprintsprocessor.dmaapclient.$selector"
val dmaapProps = dmaapClientProperties(prefix)
return blueprintDmaapClientService(dmaapProps)
}
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"DMAAP adaptor($type) is " +
"not supported"
)
}
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"DMAAP adaptor($type) is " +
"not supported"
)
* Returns DMAAP client service according to the type of client properties.
*/
private fun blueprintDmaapClientService(clientProps: DmaapClientProperties):
- BluePrintDmaapClientService {
+ BlueprintDmaapClientService {
when (clientProps) {
is HttpNoAuthDmaapClientProperties -> {
return HttpNoAuthDmaapClientService(clientProps)
}
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Unable to get the DMAAP " +
"client"
)
private val clientProps:
HttpNoAuthDmaapClientProperties
) :
- BluePrintDmaapClientService {
+ BlueprintDmaapClientService {
/**
* The constructed DMAAP client.
import com.fasterxml.jackson.databind.ObjectMapper
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.dmaap.BluePrintDmaapLibConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.dmaap.BluePrintDmaapLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.dmaap.BlueprintDmaapLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.dmaap.BlueprintDmaapLibPropertyService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@ContextConfiguration(
classes = [
- BluePrintDmaapLibConfiguration::class, TestController::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintDmaapLibConfiguration::class, TestController::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
class TestDmaapEventPublisher {
@Autowired
- lateinit var dmaapService: BluePrintDmaapLibPropertyService
+ lateinit var dmaapService: BlueprintDmaapLibPropertyService
/**
* Tests the event properties being set properly and sent as request.
package org.onap.ccsdk.cds.blueprintsprocessor.grpc
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BluePrintGrpcClientService
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BluePrintGrpcLibPropertyService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BlueprintGrpcClientService
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BlueprintGrpcLibPropertyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
@Configuration
@ComponentScan
-open class BluePrintGrpcLibConfiguration
+open class BlueprintGrpcLibConfiguration
/**
* Exposed Dependency Service by this GRPC Lib Module
*/
-fun BluePrintDependencyService.grpcLibPropertyService(): BluePrintGrpcLibPropertyService =
+fun BlueprintDependencyService.grpcLibPropertyService(): BlueprintGrpcLibPropertyService =
instance(GRPCLibConstants.SERVICE_BLUEPRINT_GRPC_LIB_PROPERTY)
-fun BluePrintDependencyService.grpcClientService(selector: String): BluePrintGrpcClientService {
+fun BlueprintDependencyService.grpcClientService(selector: String): BlueprintGrpcClientService {
return grpcLibPropertyService().blueprintGrpcClientService(selector)
}
-fun BluePrintDependencyService.grpcClientService(jsonNode: JsonNode): BluePrintGrpcClientService {
+fun BlueprintDependencyService.grpcClientService(jsonNode: JsonNode): BlueprintGrpcClientService {
return grpcLibPropertyService().blueprintGrpcClientService(jsonNode)
}
package org.onap.ccsdk.cds.blueprintsprocessor.grpc
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
/** Relationships Types DSL for GRPC Server Producer */
fun ServiceTemplateBuilder.relationshipTypeConnectsToGrpcServer() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToGrpcServer()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToGrpcServer()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToGrpcServer(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToGrpcServer(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship connects to through GRPC Server."
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
fun ServiceTemplateBuilder.relationshipTypeConnectsToGrpcClient() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToGrpcClient()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToGrpcClient()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToGrpcClient(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToGrpcClient(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship connects to through GRPC Client."
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
class GrpcServerRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER, description
) {
fun tokenAuth(block: GrpcServerTokenAuthPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.tokenAuthGrpcServerProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.tokenAuthGrpcServerProperties(block))
}
fun tlsAuth(block: GrpcServerTLSAuthPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.tlsAuthGrpcServerProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.tlsAuthGrpcServerProperties(block))
}
}
-fun BluePrintTypes.tokenAuthGrpcServerProperties(block: GrpcServerTokenAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.tokenAuthGrpcServerProperties(block: GrpcServerTokenAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = GrpcServerTokenAuthPropertiesAssignmentBuilder().apply(block).build()
assignments[GrpcServerProperties::type.name] = GRPCLibConstants.TYPE_TOKEN_AUTH.asJsonPrimitive()
return assignments.asJsonNode()
}
-fun BluePrintTypes.tlsAuthGrpcServerProperties(block: GrpcServerTLSAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.tlsAuthGrpcServerProperties(block: GrpcServerTLSAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = GrpcServerTLSAuthPropertiesAssignmentBuilder().apply(block).build()
assignments[GrpcServerProperties::type.name] = GRPCLibConstants.TYPE_TLS_AUTH.asJsonPrimitive()
return assignments.asJsonNode()
class GrpcClientRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT, description
) {
fun basicAuth(block: GrpcClientBasicAuthPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.basicAuthGrpcClientProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.basicAuthGrpcClientProperties(block))
}
fun tokenAuth(block: GrpcClientTokenAuthPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.tokenAuthGrpcClientProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.tokenAuthGrpcClientProperties(block))
}
fun tlsAuth(block: GrpcClientTLSAuthPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.tlsAuthGrpcClientProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.tlsAuthGrpcClientProperties(block))
}
}
-fun BluePrintTypes.basicAuthGrpcClientProperties(block: GrpcClientBasicAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.basicAuthGrpcClientProperties(block: GrpcClientBasicAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = GrpcClientBasicAuthPropertiesAssignmentBuilder().apply(block).build()
assignments[GrpcClientProperties::type.name] = GRPCLibConstants.TYPE_BASIC_AUTH.asJsonPrimitive()
return assignments.asJsonNode()
}
-fun BluePrintTypes.tokenAuthGrpcClientProperties(block: GrpcClientTokenAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.tokenAuthGrpcClientProperties(block: GrpcClientTokenAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = GrpcClientTokenAuthPropertiesAssignmentBuilder().apply(block).build()
assignments[GrpcClientProperties::type.name] = GRPCLibConstants.TYPE_TOKEN_AUTH.asJsonPrimitive()
return assignments.asJsonNode()
}
-fun BluePrintTypes.tlsAuthGrpcClientProperties(block: GrpcClientTLSAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.tlsAuthGrpcClientProperties(block: GrpcClientTLSAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = GrpcClientTLSAuthPropertiesAssignmentBuilder().apply(block).build()
assignments[GrpcClientProperties::type.name] = GRPCLibConstants.TYPE_TLS_AUTH.asJsonPrimitive()
return assignments.asJsonNode()
import io.grpc.ServerCallHandler
import io.grpc.ServerInterceptor
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.GrpcLoggerService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.slf4j.MDC
when (message) {
is ExecutionServiceInput -> {
val commonHeader = message.commonHeader
- ?: throw BluePrintProcessorException("missing common header in request")
+ ?: throw BlueprintProcessorException("missing common header in request")
loggingService.grpcRequesting(call, commonHeader, next)
}
- is BluePrintUploadInput -> {
+ is BlueprintUploadInput -> {
val commonHeader = message.commonHeader
- ?: throw BluePrintProcessorException("missing common header in request")
+ ?: throw BlueprintProcessorException("missing common header in request")
loggingService.grpcRequesting(call, commonHeader, next)
}
- is BluePrintDownloadInput -> {
+ is BlueprintDownloadInput -> {
val commonHeader = message.commonHeader
- ?: throw BluePrintProcessorException("missing common header in request")
+ ?: throw BlueprintProcessorException("missing common header in request")
loggingService.grpcRequesting(call, commonHeader, next)
}
- is BluePrintRemoveInput -> {
+ is BlueprintRemoveInput -> {
val commonHeader = message.commonHeader
- ?: throw BluePrintProcessorException("missing common header in request")
+ ?: throw BlueprintProcessorException("missing common header in request")
loggingService.grpcRequesting(call, commonHeader, next)
}
else -> {
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.BasicAuthGrpcClientProperties
open class BasicAuthGrpcClientService(private val basicAuthGrpcClientProperties: BasicAuthGrpcClientProperties) :
- BluePrintGrpcClientService {
+ BlueprintGrpcClientService {
override suspend fun channel(): ManagedChannel {
val managedChannel = NettyChannelBuilder
package org.onap.ccsdk.cds.blueprintsprocessor.grpc.service
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.BasicAuthGrpcClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.GRPCLibConstants
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.GrpcClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.TLSAuthGrpcServerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.TokenAuthGrpcClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.TokenAuthGrpcServerProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.returnNullIfMissing
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.stereotype.Service
@Service(GRPCLibConstants.SERVICE_BLUEPRINT_GRPC_LIB_PROPERTY)
-open class BluePrintGrpcLibPropertyService(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+open class BlueprintGrpcLibPropertyService(private var bluePrintPropertiesService: BlueprintPropertiesService) {
- fun blueprintGrpcServerService(jsonNode: JsonNode): BluePrintGrpcServerService {
+ fun blueprintGrpcServerService(jsonNode: JsonNode): BlueprintGrpcServerService {
val grpcServerProperties = grpcServerProperties(jsonNode)
return blueprintGrpcServerService(grpcServerProperties)
}
- fun blueprintGrpcServerService(selector: String): BluePrintGrpcServerService {
+ fun blueprintGrpcServerService(selector: String): BlueprintGrpcServerService {
val prefix = "${GRPCLibConstants.PROPERTY_GRPC_SERVER_PREFIX}$selector"
val grpcServerProperties = grpcServerProperties(prefix)
return blueprintGrpcServerService(grpcServerProperties)
JacksonUtils.readValue(jsonNode, TLSAuthGrpcServerProperties::class.java)!!
}
else -> {
- throw BluePrintProcessorException("Grpc type($type) not supported")
+ throw BlueprintProcessorException("Grpc type($type) not supported")
}
}
}
tlsAuthGrpcServerProperties(prefix)
}
else -> {
- throw BluePrintProcessorException("Grpc type($type) not supported")
+ throw BlueprintProcessorException("Grpc type($type) not supported")
}
}
}
}
private fun blueprintGrpcServerService(grpcServerProperties: GrpcServerProperties):
- BluePrintGrpcServerService {
+ BlueprintGrpcServerService {
when (grpcServerProperties) {
is TLSAuthGrpcServerProperties -> {
return TLSAuthGrpcServerService(grpcServerProperties)
}
else -> {
- throw BluePrintProcessorException("couldn't get grpc client service for properties $grpcServerProperties")
+ throw BlueprintProcessorException("couldn't get grpc client service for properties $grpcServerProperties")
}
}
}
/** GRPC Client Lib Property Service */
- fun blueprintGrpcClientService(jsonNode: JsonNode): BluePrintGrpcClientService {
+ fun blueprintGrpcClientService(jsonNode: JsonNode): BlueprintGrpcClientService {
val restClientProperties = grpcClientProperties(jsonNode)
return blueprintGrpcClientService(restClientProperties)
}
- fun blueprintGrpcClientService(selector: String): BluePrintGrpcClientService {
+ fun blueprintGrpcClientService(selector: String): BlueprintGrpcClientService {
val prefix = "${GRPCLibConstants.PROPERTY_GRPC_CLIENT_PREFIX}$selector"
val restClientProperties = grpcClientProperties(prefix)
return blueprintGrpcClientService(restClientProperties)
fun grpcClientProperties(jsonNode: JsonNode): GrpcClientProperties {
val type = jsonNode.get("type").returnNullIfMissing()?.textValue()
- ?: BluePrintProcessorException("missing type property")
+ ?: BlueprintProcessorException("missing type property")
return when (type) {
GRPCLibConstants.TYPE_TOKEN_AUTH -> {
JacksonUtils.readValue(jsonNode, TokenAuthGrpcClientProperties::class.java)!!
JacksonUtils.readValue(jsonNode, BasicAuthGrpcClientProperties::class.java)!!
}
else -> {
- throw BluePrintProcessorException("Grpc type($type) not supported")
+ throw BlueprintProcessorException("Grpc type($type) not supported")
}
}
}
basicAuthGrpcClientProperties(prefix)
}
else -> {
- throw BluePrintProcessorException("Grpc type($type) not supported")
+ throw BlueprintProcessorException("Grpc type($type) not supported")
}
}
}
fun blueprintGrpcClientService(grpcClientProperties: GrpcClientProperties):
- BluePrintGrpcClientService {
+ BlueprintGrpcClientService {
return when (grpcClientProperties) {
is TokenAuthGrpcClientProperties -> {
TokenAuthGrpcClientService(grpcClientProperties)
BasicAuthGrpcClientService(grpcClientProperties)
}
else -> {
- throw BluePrintProcessorException("couldn't get grpc service for type(${grpcClientProperties.type})")
+ throw BlueprintProcessorException("couldn't get grpc service for type(${grpcClientProperties.type})")
}
}
}
import io.grpc.ManagedChannel
import io.grpc.netty.NettyServerBuilder
-interface BluePrintGrpcServerService {
+interface BlueprintGrpcServerService {
fun serverBuilder(): NettyServerBuilder
}
-interface BluePrintGrpcClientService {
+interface BlueprintGrpcClientService {
suspend fun channel(): ManagedChannel
}
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.getStringKey
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.putStringKeyValue
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_INVOCATION_ID
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_PARTNER_NAME
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_REQUEST_ID
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_INVOCATION_ID
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_PARTNER_NAME
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_REQUEST_ID
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.defaultToEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.defaultToUUID
import org.onap.ccsdk.cds.controllerblueprints.core.logger
val localhost = InetAddress.getLocalHost()
val clientSocketAddress = call.attributes.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR) as? InetSocketAddress
- ?: throw BluePrintProcessorException("failed to get client address")
+ ?: throw BlueprintProcessorException("failed to get client address")
val serviceName = call.methodDescriptor.fullMethodName
MDC.put("InvokeTimestamp", ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT))
fun grpcInvoking(requestHeader: Metadata) {
requestHeader.putStringKeyValue(ONAP_REQUEST_ID, MDC.get("InvocationID").defaultToUUID())
requestHeader.putStringKeyValue(ONAP_INVOCATION_ID, UUID.randomUUID().toString())
- requestHeader.putStringKeyValue(ONAP_PARTNER_NAME, BluePrintConstants.APP_NAME)
+ requestHeader.putStringKeyValue(ONAP_PARTNER_NAME, BlueprintConstants.APP_NAME)
}
/** Used when server returns response */
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
class TLSAuthGrpcClientService(private val tlsAuthGrpcClientProperties: TLSAuthGrpcClientProperties) :
- BluePrintGrpcClientService {
+ BlueprintGrpcClientService {
override suspend fun channel(): ManagedChannel {
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
class TLSAuthGrpcServerService(private val tlsAuthGrpcServerProperties: TLSAuthGrpcServerProperties) :
- BluePrintGrpcServerService {
+ BlueprintGrpcServerService {
override fun serverBuilder(): NettyServerBuilder {
return NettyServerBuilder
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.interceptor.GrpcClientLoggingInterceptor
class TokenAuthGrpcClientService(private val tokenAuthGrpcClientProperties: TokenAuthGrpcClientProperties) :
- BluePrintGrpcClientService {
+ BlueprintGrpcClientService {
override suspend fun channel(): ManagedChannel {
val target =
package org.onap.ccsdk.cds.blueprintsprocessor.grpc
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.relationshipTypeConnectsTo
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
import kotlin.test.assertEquals
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_SERVER}"
)
}
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_GRPC_CLIENT}"
)
}
}
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.BasicAuthGrpcClientProperties
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.BluePrintGrpcLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.BlueprintGrpcLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.TLSAuthGrpcClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.TLSAuthGrpcServerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.TokenAuthGrpcClientProperties
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- BluePrintGrpcLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintGrpcLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
"blueprintsprocessor.grpcclient.tls-sample.clientPrivateKey=client.key"
]
)
-class BluePrintGrpcLibPropertyServiceTest {
+class BlueprintGrpcLibPropertyServiceTest {
@Autowired
- lateinit var bluePrintGrpcLibPropertyService: BluePrintGrpcLibPropertyService
+ lateinit var bluePrintGrpcLibPropertyService: BlueprintGrpcLibPropertyService
/**
* Tests the GRPC client properties with selector for basic auth.
import org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import java.util.UUID
import kotlin.test.Test
import kotlin.test.assertNotNull
-class BluePrintGrpcServerTest {
+class BlueprintGrpcServerTest {
private val tlsAuthGrpcServerProperties = TLSAuthGrpcServerProperties().apply {
port = 50052
val grpcChannel = tlsAuthGrpcClientService.channel()
/** Get Send and Receive Channel for bidirectional process method*/
val (reqChannel, resChannel) = clientCallBidiStreaming(
- BluePrintProcessingServiceGrpc.getProcessMethod(),
+ BlueprintProcessingServiceGrpc.getProcessMethod(),
grpcChannel
)
launch {
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
-val log = logger(MockTLSBluePrintProcessingServer::class)
+val log = logger(MockTLSBlueprintProcessingServer::class)
/** For Integration testing stat this server, Set the working path to run this method */
fun main() {
}
val server = TLSAuthGrpcServerService(tlsAuthGrpcServerProperties).serverBuilder()
.intercept(GrpcServerLoggingInterceptor())
- .addService(MockTLSBluePrintProcessingServer())
+ .addService(MockTLSBlueprintProcessingServer())
.build()
server.start()
log.info("GRPC Serve started(${server.isShutdown}) on port(${server.port})...")
}
}
-class MockTLSBluePrintProcessingServer : BluePrintProcessingServiceGrpc.BluePrintProcessingServiceImplBase() {
+class MockTLSBlueprintProcessingServer : BlueprintProcessingServiceGrpc.BlueprintProcessingServiceImplBase() {
override fun process(responseObserver: StreamObserver<ExecutionServiceOutput>): StreamObserver<ExecutionServiceInput> {
package org.onap.ccsdk.cds.blueprintsprocessor.message
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BluePrintMessageLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageConsumerService
import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageProducerService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
@Configuration
@ComponentScan
@EnableConfigurationProperties
-open class BluePrintMessageLibConfiguration
+open class BlueprintMessageLibConfiguration
/**
* Exposed Dependency Service by this Message Lib Module
*/
-fun BluePrintDependencyService.messageLibPropertyService(): BluePrintMessageLibPropertyService =
+fun BlueprintDependencyService.messageLibPropertyService(): BlueprintMessageLibPropertyService =
instance(MessageLibConstants.SERVICE_BLUEPRINT_MESSAGE_LIB_PROPERTY)
/** Extension functions for message producer service **/
-fun BluePrintDependencyService.messageProducerService(selector: String): BlueprintMessageProducerService {
+fun BlueprintDependencyService.messageProducerService(selector: String): BlueprintMessageProducerService {
return messageLibPropertyService().blueprintMessageProducerService(selector)
}
-fun BluePrintDependencyService.messageProducerService(jsonNode: JsonNode): BlueprintMessageProducerService {
+fun BlueprintDependencyService.messageProducerService(jsonNode: JsonNode): BlueprintMessageProducerService {
return messageLibPropertyService().blueprintMessageProducerService(jsonNode)
}
/** Extension functions for message consumer service **/
-fun BluePrintDependencyService.messageConsumerService(selector: String): BlueprintMessageConsumerService {
+fun BlueprintDependencyService.messageConsumerService(selector: String): BlueprintMessageConsumerService {
return messageLibPropertyService().blueprintMessageConsumerService(selector)
}
-fun BluePrintDependencyService.messageConsumerService(jsonNode: JsonNode): BlueprintMessageConsumerService {
+fun BlueprintDependencyService.messageConsumerService(jsonNode: JsonNode): BlueprintMessageConsumerService {
return messageLibPropertyService().blueprintMessageConsumerService(jsonNode)
}
package org.onap.ccsdk.cds.blueprintsprocessor.message
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
/** Relationships Types DSL for Message Producer */
fun ServiceTemplateBuilder.relationshipTypeConnectsToMessageProducer() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToMessageProducer()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToMessageProducer()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToMessageProducer(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToMessageProducer(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship connects to through message producer."
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
fun ServiceTemplateBuilder.relationshipTypeConnectsToMessageConsumer() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToMessageConsumer()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToMessageConsumer()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToMessageConsumer(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToMessageConsumer(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship type connects to message consumer."
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
class MessageProducerRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER, description
) {
fun kafkaBasicAuth(block: KafkaBasicAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaBasicAuthMessageProducerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaBasicAuthMessageProducerProperties(block)
)
}
fun kafkaSslAuth(block: KafkaSslAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaSslAuthMessageProducerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaSslAuthMessageProducerProperties(block)
)
}
fun kafkaScramSslAuth(block: KafkaScramSslAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaScramSslAuthMessageProducerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaScramSslAuthMessageProducerProperties(block)
)
}
}
-fun BluePrintTypes.kafkaBasicAuthMessageProducerProperties(block: KafkaBasicAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaBasicAuthMessageProducerProperties(block: KafkaBasicAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaBasicAuthMessageProducerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaBasicAuthMessageProducerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_BASIC_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.kafkaSslAuthMessageProducerProperties(block: KafkaSslAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaSslAuthMessageProducerProperties(block: KafkaSslAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaSslAuthMessageProducerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaSslAuthMessageProducerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_SSL_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.kafkaScramSslAuthMessageProducerProperties(block: KafkaScramSslAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaScramSslAuthMessageProducerProperties(block: KafkaScramSslAuthMessageProducerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaScramSslAuthMessageProducerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaScramSslAuthMessageProducerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_SCRAM_SSL_AUTH.asJsonPrimitive()
class MessageConsumerRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER, description
) {
fun kafkaBasicAuth(block: KafkaBasicAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaBasicAuthMessageConsumerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaBasicAuthMessageConsumerProperties(block)
)
}
fun kafkaSslAuth(block: KafkaSslAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaSslAuthMessageConsumerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaSslAuthMessageConsumerProperties(block)
)
}
fun kafkaScramSslAuth(block: KafkaScramSslAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaScramSslAuthMessageConsumerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaScramSslAuthMessageConsumerProperties(block)
)
}
fun kafkaStreamsBasicAuth(block: KafkaStreamsBasicAuthConsumerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaStreamsBasicAuthConsumerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaStreamsBasicAuthConsumerProperties(block)
)
}
fun kafkaStreamsSslAuth(block: KafkaStreamsSslAuthConsumerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaStreamsSslAuthConsumerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaStreamsSslAuthConsumerProperties(block)
)
}
fun kafkaStreamsScramSslAuth(block: KafkaStreamsScramSslAuthConsumerPropertiesAssignmentBuilder.() -> Unit) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintTypes.kafkaStreamsScramSslAuthConsumerProperties(block)
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintTypes.kafkaStreamsScramSslAuthConsumerProperties(block)
)
}
}
-fun BluePrintTypes.kafkaBasicAuthMessageConsumerProperties(block: KafkaBasicAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaBasicAuthMessageConsumerProperties(block: KafkaBasicAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaBasicAuthMessageConsumerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaBasicAuthMessageConsumerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_BASIC_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.kafkaSslAuthMessageConsumerProperties(block: KafkaSslAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaSslAuthMessageConsumerProperties(block: KafkaSslAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaSslAuthMessageConsumerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaSslAuthMessageConsumerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_SSL_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.kafkaScramSslAuthMessageConsumerProperties(block: KafkaScramSslAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaScramSslAuthMessageConsumerProperties(block: KafkaScramSslAuthMessageConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaScramSslAuthMessageConsumerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaScramSslAuthMessageConsumerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_SCRAM_SSL_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.kafkaStreamsBasicAuthConsumerProperties(block: KafkaStreamsBasicAuthConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaStreamsBasicAuthConsumerProperties(block: KafkaStreamsBasicAuthConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaStreamsBasicAuthConsumerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaStreamsBasicAuthConsumerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_STREAMS_BASIC_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.kafkaStreamsSslAuthConsumerProperties(block: KafkaStreamsSslAuthConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaStreamsSslAuthConsumerProperties(block: KafkaStreamsSslAuthConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaStreamsSslAuthConsumerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaStreamsSslAuthConsumerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_STREAMS_SSL_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.kafkaStreamsScramSslAuthConsumerProperties(block: KafkaStreamsScramSslAuthConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.kafkaStreamsScramSslAuthConsumerProperties(block: KafkaStreamsScramSslAuthConsumerPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = KafkaStreamsScramSslAuthConsumerPropertiesAssignmentBuilder().apply(block).build()
assignments[KafkaStreamsScramSslAuthConsumerProperties::type.name] =
MessageLibConstants.TYPE_KAFKA_STREAMS_SCRAM_SSL_AUTH.asJsonPrimitive()
import org.onap.ccsdk.cds.controllerblueprints.core.logger
/** CDS Kafka Stream Processor abstract class to implement */
-abstract class AbstractBluePrintMessageProcessor<K, V> : Processor<K, V> {
+abstract class AbstractBlueprintMessageProcessor<K, V> : Processor<K, V> {
- private val log = logger(AbstractBluePrintMessageProcessor::class)
+ private val log = logger(AbstractBlueprintMessageProcessor::class)
lateinit var processorContext: ProcessorContext
}
/** CDS Kafka Stream Punctuator abstract class to implement */
-abstract class AbstractBluePrintMessagePunctuator : Punctuator {
+abstract class AbstractBlueprintMessagePunctuator : Punctuator {
lateinit var processorContext: ProcessorContext
import org.apache.kafka.streams.processor.StateStore
import org.apache.kafka.streams.state.StoreBuilder
import org.apache.kafka.streams.state.StoreSupplier
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibGenericService
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibGenericService
import org.onap.ccsdk.cds.blueprintsprocessor.db.primaryDBLibGenericService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import java.util.*
override fun get(): KafkaJDBCStore {
// Get the DBLibGenericService Instance
- val bluePrintDBLibGenericService = BluePrintDependencyService.primaryDBLibGenericService()
+ val bluePrintDBLibGenericService = BlueprintDependencyService.primaryDBLibGenericService()
return KafkaJDBCStoreImpl(name, bluePrintDBLibGenericService)
}
class KafkaJDBCStoreImpl(private val name: String,
- private val bluePrintDBLibGenericService: BluePrintDBLibGenericService)
+ private val bluePrintDBLibGenericService: BlueprintDBLibGenericService)
: KafkaJDBCStore {
private val log = logger(KafkaJDBCStoreImpl::class)
import org.apache.kafka.clients.consumer.ConsumerRecords
import org.apache.kafka.streams.Topology
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageConsumerProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
/** Consumer Function Interfaces */
interface ConsumerFunction
/** Consume with [additionalConfig], so that we can execute dynamic function [consumerFunction] */
suspend fun consume(additionalConfig: Map<String, Any>?, consumerFunction: ConsumerFunction) {
- throw BluePrintProcessorException("Not Implemented")
+ throw BlueprintProcessorException("Not Implemented")
}
/** Consume the [topics] with [additionalConfig], so that we can execute dynamic function [consumerFunction] */
additionalConfig: Map<String, Any>?,
consumerFunction: ConsumerFunction
) {
- throw BluePrintProcessorException("Not Implemented")
+ throw BlueprintProcessorException("Not Implemented")
}
/** close the channel, consumer and other resources */
package org.onap.ccsdk.cds.blueprintsprocessor.message.service
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.message.KafkaBasicAuthMessageConsumerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.message.KafkaBasicAuthMessageProducerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.message.KafkaScramSslAuthMessageConsumerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageConsumerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageLibConstants
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageProducerProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.stereotype.Service
@Service(MessageLibConstants.SERVICE_BLUEPRINT_MESSAGE_LIB_PROPERTY)
-open class BluePrintMessageLibPropertyService(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+open class BlueprintMessageLibPropertyService(private var bluePrintPropertiesService: BlueprintPropertiesService) {
fun blueprintMessageProducerService(jsonNode: JsonNode): BlueprintMessageProducerService {
val messageClientProperties = messageProducerProperties(jsonNode)
)
}
else -> {
- throw BluePrintProcessorException("Message adaptor($type) is not supported")
+ throw BlueprintProcessorException("Message adaptor($type) is not supported")
}
}
}
JacksonUtils.readValue(jsonNode, KafkaScramSslAuthMessageProducerProperties::class.java)!!
}
else -> {
- throw BluePrintProcessorException("Message adaptor($type) is not supported")
+ throw BlueprintProcessorException("Message adaptor($type) is not supported")
}
}
}
)
}
else -> {
- throw BluePrintProcessorException("Message adaptor($type) is not supported")
+ throw BlueprintProcessorException("Message adaptor($type) is not supported")
}
}
}
JacksonUtils.readValue(jsonNode, KafkaStreamsScramSslAuthConsumerProperties::class.java)!!
}
else -> {
- throw BluePrintProcessorException("Message adaptor($type) is not supported")
+ throw BlueprintProcessorException("Message adaptor($type) is not supported")
}
}
}
)
}
else -> {
- throw BluePrintProcessorException("couldn't get message client service for ${messageConsumerProperties.type}")
+ throw BlueprintProcessorException("couldn't get message client service for ${messageConsumerProperties.type}")
}
}
}
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.streams.KafkaStreams
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageConsumerProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import java.util.Properties
}
override suspend fun subscribe(additionalConfig: Map<String, Any>?): Channel<ConsumerRecord<String, ByteArray>> {
- throw BluePrintProcessorException("not implemented")
+ throw BlueprintProcessorException("not implemented")
}
override suspend fun subscribe(topics: List<String>, additionalConfig: Map<String, Any>?): Channel<ConsumerRecord<String, ByteArray>> {
- throw BluePrintProcessorException("not implemented")
+ throw BlueprintProcessorException("not implemented")
}
override suspend fun consume(additionalConfig: Map<String, Any>?, consumerFunction: ConsumerFunction) {
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.CommonHeader
import org.onap.ccsdk.cds.blueprintsprocessor.message.addHeader
import org.onap.ccsdk.cds.blueprintsprocessor.message.toMap
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.defaultToEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.defaultToUUID
import org.onap.ccsdk.cds.controllerblueprints.core.logger
fun messageConsuming(consumerRecord: ConsumerRecord<*, *>) {
val headers = consumerRecord.headers().toMap()
- val requestID = headers[BluePrintConstants.ONAP_REQUEST_ID].defaultToUUID()
- val invocationID = headers[BluePrintConstants.ONAP_INVOCATION_ID].defaultToUUID()
- val partnerName = headers[BluePrintConstants.ONAP_PARTNER_NAME] ?: "UNKNOWN"
+ val requestID = headers[BlueprintConstants.ONAP_REQUEST_ID].defaultToUUID()
+ val invocationID = headers[BlueprintConstants.ONAP_INVOCATION_ID].defaultToUUID()
+ val partnerName = headers[BlueprintConstants.ONAP_PARTNER_NAME] ?: "UNKNOWN"
messageConsuming(requestID, invocationID, partnerName, consumerRecord)
}
*/
fun messageProducing(requestHeader: Headers) {
val localhost = InetAddress.getLocalHost()
- requestHeader.addHeader(BluePrintConstants.ONAP_REQUEST_ID, MDC.get("InvocationID").defaultToUUID())
- requestHeader.addHeader(BluePrintConstants.ONAP_INVOCATION_ID, UUID.randomUUID().toString())
- requestHeader.addHeader(BluePrintConstants.ONAP_PARTNER_NAME, BluePrintConstants.APP_NAME)
+ requestHeader.addHeader(BlueprintConstants.ONAP_REQUEST_ID, MDC.get("InvocationID").defaultToUUID())
+ requestHeader.addHeader(BlueprintConstants.ONAP_INVOCATION_ID, UUID.randomUUID().toString())
+ requestHeader.addHeader(BlueprintConstants.ONAP_PARTNER_NAME, BlueprintConstants.APP_NAME)
requestHeader.addHeader("ClientIPAddress", localhost.hostAddress)
}
import org.apache.kafka.streams.StreamsConfig
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.relationshipTypeConnectsTo
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
import kotlin.test.assertEquals
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_PRODUCER}"
)
}
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_MESSAGE_CONSUMER}"
)
}
}
import org.apache.kafka.common.serialization.StringDeserializer
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.message.BluePrintMessageLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.message.BlueprintMessageLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageConsumerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageLibConstants
import org.onap.ccsdk.cds.controllerblueprints.core.logger
@DirtiesContext
@ContextConfiguration(
classes = [
- BluePrintMessageLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintMessageLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
val log = logger(BlueprintMessageConsumerServiceTest::class)
@Autowired
- lateinit var bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService
+ lateinit var bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService
@Test
fun testKafkaBasicAuthConsumerService() {
import org.apache.kafka.common.serialization.ByteArraySerializer
import org.apache.kafka.common.serialization.StringSerializer
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.message.BluePrintMessageLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.message.BlueprintMessageLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageLibConstants
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.annotation.DirtiesContext
@DirtiesContext
@ContextConfiguration(
classes = [
- BluePrintMessageLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintMessageLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
open class BlueprintMessageProducerServiceTest {
@Autowired
- lateinit var bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService
+ lateinit var bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService
@Test
fun testKafkaScramSslAuthProducerService() {
every { mockKafkaTemplate.send(any(), any()) } returns responseMock
- val spyBluePrintMessageProducerService = spyk(blueprintMessageProducerService, recordPrivateCalls = true)
+ val spyBlueprintMessageProducerService = spyk(blueprintMessageProducerService, recordPrivateCalls = true)
- every { spyBluePrintMessageProducerService.messageTemplate(any()) } returns mockKafkaTemplate
+ every { spyBlueprintMessageProducerService.messageTemplate(any()) } returns mockKafkaTemplate
- val response = spyBluePrintMessageProducerService.sendMessage("mykey", "Testing message")
+ val response = spyBlueprintMessageProducerService.sendMessage("mykey", "Testing message")
assertTrue(response, "failed to get command response")
}
}
import org.apache.kafka.streams.state.Stores
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.message.BluePrintMessageLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.message.BlueprintMessageLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.message.KafkaStreamsBasicAuthConsumerProperties
import org.onap.ccsdk.cds.blueprintsprocessor.message.MessageConsumerProperties
import org.springframework.beans.factory.annotation.Autowired
@DirtiesContext
@ContextConfiguration(
classes = [
- BluePrintMessageLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintMessageLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
class KafkaStreamsConsumerServiceTest {
@Autowired
- lateinit var bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService
+ lateinit var bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService
@Test
fun testProperties() {
import org.junit.Test
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.CommonHeader
import org.onap.ccsdk.cds.blueprintsprocessor.message.toMap
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.slf4j.MDC
import kotlin.test.assertEquals
val mockHeaders = RecordHeaders()
messageLoggerService.messageProducing(mockHeaders)
val map = mockHeaders.toMap()
- assertEquals("1234-12", map[BluePrintConstants.ONAP_REQUEST_ID])
+ assertEquals("1234-12", map[BlueprintConstants.ONAP_REQUEST_ID])
messageLoggerService.messageConsumingExisting()
}
import org.apache.kafka.streams.processor.Processor
import org.apache.kafka.streams.processor.ProcessorContext
import org.apache.kafka.streams.state.KeyValueStore
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
return object : Deserializer<PriorityMessage> {
override fun deserialize(topic: String, data: ByteArray): PriorityMessage {
return JacksonUtils.readValue(String(data), PriorityMessage::class.java)
- ?: throw BluePrintProcessorException("failed to convert")
+ ?: throw BlueprintProcessorException("failed to convert")
}
override fun configure(configs: MutableMap<String, *>?, isKey: Boolean) {
package org.onap.ccsdk.cds.blueprintsprocessor.nats
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BluePrintNatsLibPropertyService
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BluePrintNatsService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BlueprintNatsLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.service.BlueprintNatsService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
@Configuration
@ComponentScan
-open class BluePrintNatsLibConfiguration
+open class BlueprintNatsLibConfiguration
/**
* Exposed Dependency Service by this NATS Lib Module
*/
-fun BluePrintDependencyService.natsLibPropertyService(): BluePrintNatsLibPropertyService =
+fun BlueprintDependencyService.natsLibPropertyService(): BlueprintNatsLibPropertyService =
instance(NatsLibConstants.SERVICE_BLUEPRINT_NATS_LIB_PROPERTY)
-fun BluePrintDependencyService.controllerNatsService(): BluePrintNatsService {
+fun BlueprintDependencyService.controllerNatsService(): BlueprintNatsService {
return natsLibPropertyService().bluePrintNatsService(NatsLibConstants.DEFULT_NATS_SELECTOR)
}
package org.onap.ccsdk.cds.blueprintsprocessor.nats
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
/** Relationships Types DSL for NATS Producer */
fun ServiceTemplateBuilder.relationshipTypeConnectsToNats() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToNats()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToNats()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToNats(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToNats(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship connects to through NATS Client."
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
class NatsRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS, description
) {
fun tokenAuth(block: NatsTokenAuthPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.tokenAuthNatsProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.tokenAuthNatsProperties(block))
}
fun tlsAuth(block: NatsTLSAuthPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.tlsAuthNatsProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.tlsAuthNatsProperties(block))
}
}
-fun BluePrintTypes.tokenAuthNatsProperties(block: NatsTokenAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.tokenAuthNatsProperties(block: NatsTokenAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = NatsTokenAuthPropertiesAssignmentBuilder().apply(block).build()
assignments[NatsConnectionProperties::type.name] = NatsLibConstants.TYPE_TOKEN_AUTH.asJsonPrimitive()
return assignments.asJsonNode()
}
-fun BluePrintTypes.tlsAuthNatsProperties(block: NatsTLSAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.tlsAuthNatsProperties(block: NatsTLSAuthPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = NatsTLSAuthPropertiesAssignmentBuilder().apply(block).build()
assignments[NatsConnectionProperties::type.name] = NatsLibConstants.TYPE_TLS_AUTH.asJsonPrimitive()
return assignments.asJsonNode()
package org.onap.ccsdk.cds.blueprintsprocessor.nats.service
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.nats.NatsConnectionProperties
import org.onap.ccsdk.cds.blueprintsprocessor.nats.NatsLibConstants
import org.onap.ccsdk.cds.blueprintsprocessor.nats.TLSAuthNatsConnectionProperties
import org.onap.ccsdk.cds.blueprintsprocessor.nats.TokenAuthNatsConnectionProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.stereotype.Service
@Service(NatsLibConstants.SERVICE_BLUEPRINT_NATS_LIB_PROPERTY)
-open class BluePrintNatsLibPropertyService(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+open class BlueprintNatsLibPropertyService(private var bluePrintPropertiesService: BlueprintPropertiesService) {
- fun bluePrintNatsService(jsonNode: JsonNode): BluePrintNatsService {
+ fun bluePrintNatsService(jsonNode: JsonNode): BlueprintNatsService {
val natsConnectionProperties = natsConnectionProperties(jsonNode)
return bluePrintNatsService(natsConnectionProperties)
}
- fun bluePrintNatsService(selector: String): BluePrintNatsService {
+ fun bluePrintNatsService(selector: String): BlueprintNatsService {
val prefix = "${NatsLibConstants.PROPERTY_NATS_PREFIX}$selector"
val natsConnectionProperties = natsConnectionProperties(prefix)
return bluePrintNatsService(natsConnectionProperties)
JacksonUtils.readValue(jsonNode, TLSAuthNatsConnectionProperties::class.java)!!
}
else -> {
- throw BluePrintProcessorException("NATS type($type) not supported")
+ throw BlueprintProcessorException("NATS type($type) not supported")
}
}
}
tlsAuthNatsConnectionProperties(prefix)
}
else -> {
- throw BluePrintProcessorException("NATS type($type) not supported")
+ throw BlueprintProcessorException("NATS type($type) not supported")
}
}
}
}
fun bluePrintNatsService(natsConnectionProperties: NatsConnectionProperties):
- BluePrintNatsService {
+ BlueprintNatsService {
return when (natsConnectionProperties) {
is TokenAuthNatsConnectionProperties -> {
TokenAuthNatsService(natsConnectionProperties)
TLSAuthNatsService(natsConnectionProperties)
}
else -> {
- throw BluePrintProcessorException("couldn't get NATS service for properties $natsConnectionProperties")
+ throw BlueprintProcessorException("couldn't get NATS service for properties $natsConnectionProperties")
}
}
}
import io.nats.streaming.SubscriptionOptions
import java.time.Duration
-interface BluePrintNatsService {
+interface BlueprintNatsService {
/** Create and Return the NATS streaming connection */
suspend fun connection(): StreamingConnection
import javax.net.ssl.SSLContext
open class TLSAuthNatsService(private val natsConnectionProperties: TLSAuthNatsConnectionProperties) :
- BluePrintNatsService {
+ BlueprintNatsService {
lateinit var streamingConnection: StreamingConnection
import org.onap.ccsdk.cds.controllerblueprints.core.splitCommaAsList
open class TokenAuthNatsService(private val natsConnectionProperties: TokenAuthNatsConnectionProperties) :
- BluePrintNatsService {
+ BlueprintNatsService {
private val log = logger(TokenAuthNatsService::class)
package org.onap.ccsdk.cds.blueprintsprocessor.nats.utils
import org.onap.ccsdk.cds.blueprintsprocessor.nats.NatsLibConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ClusterUtils
object NatsClusterUtils {
}
fun currentApplicationSubject(subject: String): String {
- return "${BluePrintConstants.APP_NAME}.$subject"
+ return "${BlueprintConstants.APP_NAME}.$subject"
}
fun currentNodeDurable(subject: String): String {
}
fun applicationLoadBalanceGroup(): String {
- return "${BluePrintConstants.APP_NAME}"
+ return "${BlueprintConstants.APP_NAME}"
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.nats
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.getInput
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.relationshipTypeConnectsTo
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_NATS}"
)
}
}
import java.nio.charset.Charset
import kotlin.test.assertEquals
-class BluePrintNatsExtensionsTest {
+class BlueprintNatsExtensionsTest {
@Test
fun testMessageStrConversion() {
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.nats.BluePrintNatsLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.nats.BlueprintNatsLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.nats.NatsLibConstants
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- BluePrintNatsLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintNatsLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
"blueprintsprocessor.nats.cds-controller.token=tokenAuth"
]
)
-class BluePrintNatsLibPropertyServiceTest {
+class BlueprintNatsLibPropertyServiceTest {
@Autowired
- lateinit var bluePrintNatsLibPropertyService: BluePrintNatsLibPropertyService
+ lateinit var bluePrintNatsLibPropertyService: BlueprintNatsLibPropertyService
@Test
fun testNatsProperties() {
import org.onap.ccsdk.cds.controllerblueprints.core.jsonAsJsonType
import kotlin.test.assertNotNull
-class BluePrintNatsServiceTest {
+class BlueprintNatsServiceTest {
@Test
fun testTokenAuthNatService() {
}
""".trimIndent()
- val bluePrintNatsLibPropertyService = BluePrintNatsLibPropertyService(mockk())
+ val bluePrintNatsLibPropertyService = BlueprintNatsLibPropertyService(mockk())
- val spkBluePrintNatsLibPropertyService = spyk(bluePrintNatsLibPropertyService)
+ val spkBlueprintNatsLibPropertyService = spyk(bluePrintNatsLibPropertyService)
every {
- spkBluePrintNatsLibPropertyService
+ spkBlueprintNatsLibPropertyService
.bluePrintNatsService(any<NatsConnectionProperties>())
} returns TokenAuthNatsService(
mockk()
)
val bluePrintNatsService =
- spkBluePrintNatsLibPropertyService.bluePrintNatsService(configuration.jsonAsJsonType())
+ spkBlueprintNatsLibPropertyService.bluePrintNatsService(configuration.jsonAsJsonType())
assertNotNull(bluePrintNatsService, "failed to get NATS Service")
}
}
""".trimIndent()
- val bluePrintNatsLibPropertyService = BluePrintNatsLibPropertyService(mockk())
+ val bluePrintNatsLibPropertyService = BlueprintNatsLibPropertyService(mockk())
- val spkBluePrintNatsLibPropertyService = spyk(bluePrintNatsLibPropertyService)
+ val spkBlueprintNatsLibPropertyService = spyk(bluePrintNatsLibPropertyService)
every {
- spkBluePrintNatsLibPropertyService
+ spkBlueprintNatsLibPropertyService
.bluePrintNatsService(any<NatsConnectionProperties>())
} returns TLSAuthNatsService(
mockk()
)
val bluePrintNatsService =
- spkBluePrintNatsLibPropertyService.bluePrintNatsService(configuration.jsonAsJsonType())
+ spkBlueprintNatsLibPropertyService.bluePrintNatsService(configuration.jsonAsJsonType())
assertNotNull(bluePrintNatsService, "failed to get NATS Service")
}
}
}
- private fun testMultiPublish(natsService: BluePrintNatsService) {
+ private fun testMultiPublish(natsService: BlueprintNatsService) {
runBlocking {
/** Multiple Publish Message Test **/
val messageHandler1 =
}
}
- private fun testLoadBalance(natsService: BluePrintNatsService) {
+ private fun testLoadBalance(natsService: BlueprintNatsService) {
runBlocking {
/** Load balance Publish Message Test **/
val lbMessageHandler1 =
}
}
- private fun testLimitSubscription(natsService: BluePrintNatsService) {
+ private fun testLimitSubscription(natsService: BlueprintNatsService) {
runBlocking {
/** Load balance Publish Message Test **/
val lbMessageHandler1 =
}
}
- private fun testRequestReply(natsService: BluePrintNatsService) {
+ private fun testRequestReply(natsService: BlueprintNatsService) {
runBlocking {
val lbMessageHandler1 = io.nats.client.MessageHandler { message ->
println("LB RR Request Handler 1: ${String(message.data)} will reply to(${message.replyTo})")
}
}
- private fun testMultiRequestReply(natsService: BluePrintNatsService) {
+ private fun testMultiRequestReply(natsService: BlueprintNatsService) {
runBlocking {
/** Request Reply **/
val lbMessageHandler1 = io.nats.client.MessageHandler { message ->
package org.onap.ccsdk.cds.blueprintsprocessor.core
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.context.properties.bind.Bindable
import org.springframework.stereotype.Service
@Configuration
-open class BluePrintCoreConfiguration(private val bluePrintPropertiesService: BluePrintPropertiesService) {
+open class BlueprintCoreConfiguration(private val bluePrintPropertiesService: BlueprintPropertiesService) {
companion object {
}
@Bean
- open fun bluePrintLoadConfiguration(): BluePrintLoadConfiguration {
+ open fun bluePrintLoadConfiguration(): BlueprintLoadConfiguration {
return bluePrintPropertiesService
- .propertyBeanType(PREFIX_BLUEPRINT_PROCESSOR, BluePrintLoadConfiguration::class.java)
+ .propertyBeanType(PREFIX_BLUEPRINT_PROCESSOR, BlueprintLoadConfiguration::class.java)
}
}
@Configuration
-open class BluePrintPropertyConfiguration {
+open class BlueprintPropertyConfiguration {
@Autowired
lateinit var environment: Environment
}
@Service
-open class BluePrintPropertiesService(private var bluePrintPropertyConfig: BluePrintPropertyConfiguration) {
+open class BlueprintPropertiesService(private var bluePrintPropertyConfig: BlueprintPropertyConfiguration) {
- private val log = logger(BluePrintPropertiesService::class)
+ private val log = logger(BlueprintPropertiesService::class)
fun <T> propertyBeanType(prefix: String, type: Class<T>): T {
return try {
} catch (e: NoSuchElementException) {
val errMsg = "Error: missing property \"$prefix\"... Check the application.properties file."
log.error(errMsg)
- throw BluePrintProcessorException(e, errMsg)
+ throw BlueprintProcessorException(e, errMsg)
}
}
}
private val log = LoggerFactory.getLogger(BlueprintDependencyConfiguration::class.java)!!
override fun setApplicationContext(applicationContext: ApplicationContext) {
- BluePrintDependencyService.inject(applicationContext)
+ BlueprintDependencyService.inject(applicationContext)
log.info("Dependency Management module created...")
}
}
import com.fasterxml.jackson.databind.node.ObjectNode
import io.swagger.annotations.ApiModelProperty
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import java.util.Date
import java.util.UUID
var errorMessage: String? = null
@get:ApiModelProperty(required = true, value = "Message providing request status")
- var message: String = BluePrintConstants.STATUS_SUCCESS
+ var message: String = BlueprintConstants.STATUS_SUCCESS
}
open class StepData {
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.newSingleThreadContext
import kotlinx.coroutines.withContext
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterLock
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterMember
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.MDCContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
/**
* Exposed Dependency Service by this Hazelcast Lib Module
*/
-fun BluePrintDependencyService.clusterService(): BluePrintClusterService =
+fun BlueprintDependencyService.clusterService(): BlueprintClusterService =
instance(HazelcastClusterService::class)
/** Optional Cluster Service, returns only if Cluster is enabled */
-fun BluePrintDependencyService.optionalClusterService(): BluePrintClusterService? {
- return if (BluePrintConstants.CLUSTER_ENABLED) {
- BluePrintDependencyService.clusterService()
+fun BlueprintDependencyService.optionalClusterService(): BlueprintClusterService? {
+ return if (BlueprintConstants.CLUSTER_ENABLED) {
+ BlueprintDependencyService.clusterService()
} else null
}
/** Extension to convert Hazelcast Member to Blueprints Cluster Member */
fun Member.toClusterMember(): ClusterMember {
- val memberName: String = this.getAttribute(BluePrintConstants.PROPERTY_CLUSTER_NODE_ID) ?: this.uuid.toString()
+ val memberName: String = this.getAttribute(BlueprintConstants.PROPERTY_CLUSTER_NODE_ID) ?: this.uuid.toString()
return ClusterMember(
id = this.uuid.toString(),
name = memberName,
lock.unLock()
}
} else
- throw BluePrintException("Failed to acquire lock within timeout")
+ throw BlueprintException("Failed to acquire lock within timeout")
}
}
}
import com.hazelcast.topic.Message
import com.hazelcast.topic.MessageListener
import kotlinx.coroutines.delay
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterMessage
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterMessage
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterMessageListener
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterInfo
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterJoinedEvent
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterLock
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterMember
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.utils.ClusterUtils
import java.util.concurrent.TimeUnit
@Service
-open class HazelcastClusterService(private val applicationEventPublisher: ApplicationEventPublisher) : BluePrintClusterService {
+open class HazelcastClusterService(private val applicationEventPublisher: ApplicationEventPublisher) : BlueprintClusterService {
private val log = logger(HazelcastClusterService::class)
lateinit var hazelcast: HazelcastInstance
}
is ClusterInfo -> {
- System.setProperty(BluePrintConstants.PROPERTY_CLUSTER_ID, configuration.id)
- System.setProperty(BluePrintConstants.PROPERTY_CLUSTER_NODE_ID, configuration.nodeId)
+ System.setProperty(BlueprintConstants.PROPERTY_CLUSTER_ID, configuration.id)
+ System.setProperty(BlueprintConstants.PROPERTY_CLUSTER_NODE_ID, configuration.nodeId)
val memberAttributeConfig = MemberAttributeConfig()
memberAttributeConfig.setAttribute(
- BluePrintConstants.PROPERTY_CLUSTER_NODE_ID,
+ BlueprintConstants.PROPERTY_CLUSTER_NODE_ID,
configuration.nodeId
)
}
}
else -> {
- throw BluePrintProcessorException("couldn't understand the cluster configuration")
+ throw BlueprintProcessorException("couldn't understand the cluster configuration")
}
}
return ClusterLockImpl(hazelcast, name)
}
- /** Return interface may change and it will be included in BluePrintClusterService */
+ /** Return interface may change and it will be included in BlueprintClusterService */
@UseExperimental
suspend fun clusterScheduler(name: String): IScheduledExecutorService {
check(::hazelcast.isInitialized) { "failed to start and join cluster" }
check(::hazelcast.isInitialized) { "failed to start and join cluster" }
val applicationMembers: MutableMap<String, Member> = hashMapOf()
hazelcast.cluster.members.map { member ->
- val memberName: String = member.getAttribute(BluePrintConstants.PROPERTY_CLUSTER_NODE_ID)
+ val memberName: String = member.getAttribute(BlueprintConstants.PROPERTY_CLUSTER_NODE_ID)
if (memberName.startsWith(appName, true)) {
applicationMembers[memberName] = member
}
class HazelcastMessageListenerAdapter<E>(val listener: BlueprintClusterMessageListener<E>) : MessageListener<E> {
override fun onMessage(message: Message<E>?) = message?.let {
- BluePrintClusterMessage<E>(
+ BlueprintClusterMessage<E>(
BlueprintClusterTopic.valueOf(it.source as String),
it.messageObject,
it.publishTime,
package org.onap.ccsdk.cds.blueprintsprocessor.core.factory
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.slf4j.LoggerFactory
import org.springframework.context.ApplicationContext
import org.springframework.context.ApplicationContextAware
*/
interface ComponentNode {
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun validate(context: MutableMap<String, Any>, componentContext: MutableMap<String, Any?>)
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun process(context: MutableMap<String, Any>, componentContext: MutableMap<String, Any?>)
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun errorHandle(context: MutableMap<String, Any>, componentContext: MutableMap<String, Any?>)
- @Throws(BluePrintProcessorException::class)
+ @Throws(BlueprintProcessorException::class)
fun reTrigger(context: MutableMap<String, Any>, componentContext: MutableMap<String, Any?>)
}
package org.onap.ccsdk.cds.blueprintsprocessor.core.listeners
import org.onap.ccsdk.cds.blueprintsprocessor.core.cluster.BlueprintClusterTopic
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterMessage
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterMessage
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterMessageListener
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterJoinedEvent
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintCompileCache
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintCompileCache
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
import org.springframework.context.event.EventListener
import org.springframework.stereotype.Component
@Component
@ConditionalOnProperty("CLUSTER_ENABLED", havingValue = "true")
-open class BlueprintCompilerCacheMessageListener(private val clusterService: BluePrintClusterService) : BlueprintClusterMessageListener<String> {
+open class BlueprintCompilerCacheMessageListener(private val clusterService: BlueprintClusterService) : BlueprintClusterMessageListener<String> {
private val log = logger(BlueprintCompilerCacheMessageListener::class)
@EventListener(ClusterJoinedEvent::class)
clusterService.addBlueprintClusterMessageListener(BlueprintClusterTopic.BLUEPRINT_CLEAN_COMPILER_CACHE, this)
}
- override fun onMessage(message: BluePrintClusterMessage<String>?) {
+ override fun onMessage(message: BlueprintClusterMessage<String>?) {
message?.let {
log.info("Received ClusterMessage - Cleaning compile cache for blueprint (${it.payload})")
- BluePrintCompileCache.cleanClassLoader(it.payload)
+ BlueprintCompileCache.cleanClassLoader(it.payload)
}
}
}
import java.util.Properties
import java.util.UUID
-interface BluePrintClusterService {
+interface BlueprintClusterService {
/** Start the cluster with [clusterInfo], By default clustering service is disabled.
* Application module has to start cluster */
fun close()
}
-class BluePrintClusterMessage<E>(val topic: BlueprintClusterTopic, val payload: E, publishTime: Long, clusterMember: ClusterMember)
+class BlueprintClusterMessage<E>(val topic: BlueprintClusterTopic, val payload: E, publishTime: Long, clusterMember: ClusterMember)
interface BlueprintClusterMessageListener<E> {
- fun onMessage(message: BluePrintClusterMessage<E>?)
+ fun onMessage(message: BlueprintClusterMessage<E>?)
}
class ClusterJoinedEvent(source: Any) : ApplicationEvent(source)
package org.onap.ccsdk.cds.blueprintsprocessor.core.utils
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.returnNullIfMissing
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
object PayloadUtils {
fun getResponseDataFromPayload(workflowName: String, responsePayload: JsonNode): JsonNode {
return responsePayload.get("$workflowName-response").returnNullIfMissing()
- ?: throw BluePrintProcessorException("failed to get property($workflowName-response)")
+ ?: throw BlueprintProcessorException("failed to get property($workflowName-response)")
}
fun prepareInputsFromWorkflowPayload(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
payload: JsonNode,
workflowName: String
) {
}
fun prepareDynamicInputsFromWorkflowPayload(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
payload: JsonNode,
workflowName: String
) {
}
fun prepareDynamicInputsFromComponentPayload(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
payload: JsonNode
) {
payload.fields().forEach { property ->
- val path = StringBuilder(BluePrintConstants.PATH_INPUTS)
- .append(BluePrintConstants.PATH_DIVIDER).append(property.key).toString()
+ val path = StringBuilder(BlueprintConstants.PATH_INPUTS)
+ .append(BlueprintConstants.PATH_DIVIDER).append(property.key).toString()
bluePrintRuntimeService.put(path, property.value)
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.core
// TODO
-open class BluePrintPropertiesTest
+open class BlueprintPropertiesTest
import org.junit.Before
import org.junit.Test
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterLock
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import kotlin.test.assertEquals
-class BluePrintClusterExtensionsTest {
+class BlueprintClusterExtensionsTest {
private lateinit var clusterLockMock: ClusterLock
}
}
- @Test(expected = BluePrintException::class)
+ @Test(expected = BlueprintException::class)
fun `executeWithLock - should throw exception when lock was not acquired within timeout`() {
runBlocking {
every { runBlocking { clusterLockMock.tryLock(eq(0L)) } } returns false
import org.junit.After
import org.junit.Before
import org.junit.Test
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterMessage
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterMessage
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterMessageListener
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterInfo
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
@Test
fun testClientFileSystemYamlConfig() {
- System.setProperty(BluePrintConstants.PROPERTY_CLUSTER_ID, "test-cluster")
- System.setProperty(BluePrintConstants.PROPERTY_CLUSTER_NODE_ID, "node-1234")
+ System.setProperty(BlueprintConstants.PROPERTY_CLUSTER_ID, "test-cluster")
+ System.setProperty(BlueprintConstants.PROPERTY_CLUSTER_NODE_ID, "node-1234")
System.setProperty(
"hazelcast.client.config",
normalizedFile("./src/test/resources/hazelcast/hazelcast-client.yaml").absolutePath
@Test
fun testServerFileSystemYamlConfig() {
- System.setProperty(BluePrintConstants.PROPERTY_CLUSTER_ID, "test-cluster")
- System.setProperty(BluePrintConstants.PROPERTY_CLUSTER_NODE_ID, "node-1234")
+ System.setProperty(BlueprintConstants.PROPERTY_CLUSTER_ID, "test-cluster")
+ System.setProperty(BlueprintConstants.PROPERTY_CLUSTER_NODE_ID, "node-1234")
val configFile = normalizedFile("./src/test/resources/hazelcast/hazelcast.yaml")
val config = FileSystemYamlConfig(configFile)
assertNotNull(config)
}
}
- private suspend fun testMessageReceived(bluePrintClusterServices: List<BluePrintClusterService>) {
+ private suspend fun testMessageReceived(bluePrintClusterServices: List<BlueprintClusterService>) {
val sender = bluePrintClusterServices[0] as HazelcastClusterService
val receiver = bluePrintClusterServices[1] as HazelcastClusterService
val messageSent = "hello world"
val uuid = receiver.addBlueprintClusterMessageListener(
BlueprintClusterTopic.BLUEPRINT_CLEAN_COMPILER_CACHE,
object : BlueprintClusterMessageListener<String> {
- override fun onMessage(message: BluePrintClusterMessage<String>?) {
+ override fun onMessage(message: BlueprintClusterMessage<String>?) {
log.info("Message received - ${message?.payload}")
isMessageReceived = messageSent == message?.payload
}
private suspend fun createCluster(
ids: List<Int>,
joinAsClient: Boolean? = false
- ): List<BluePrintClusterService> {
+ ): List<BlueprintClusterService> {
return withContext(Dispatchers.Default) {
val deferred = ids.map { id ->
}
}
- private suspend fun testDistributedStore(bluePrintClusterServices: List<BluePrintClusterService>) {
+ private suspend fun testDistributedStore(bluePrintClusterServices: List<BlueprintClusterService>) {
/** Test Distributed store creation */
repeat(2) { storeId ->
val store = bluePrintClusterServices[0].clusterMapStore<JsonNode>(
}
}
- private suspend fun testDistributedLock(bluePrintClusterServices: List<BluePrintClusterService>) {
+ private suspend fun testDistributedLock(bluePrintClusterServices: List<BlueprintClusterService>) {
val lockName = "sample-lock"
withContext(Dispatchers.IO) {
val deferred = async {
}
private suspend fun executeLock(
- bluePrintClusterService: BluePrintClusterService,
+ bluePrintClusterService: BlueprintClusterService,
lockId: String,
lockName: String
) {
distributedLock.close()
}
- private suspend fun executeScheduler(bluePrintClusterService: BluePrintClusterService) {
+ private suspend fun executeScheduler(bluePrintClusterService: BlueprintClusterService) {
log.info("initialising ...")
val hazelcastClusterService = bluePrintClusterService as HazelcastClusterService
// scheduler.scheduleOnAllMembersAtFixedRate(SampleSchedulerTask(), 0, 5, TimeUnit.SECONDS)
}
- private suspend fun printReachableMembers(bluePrintClusterServices: List<BluePrintClusterService>) {
+ private suspend fun printReachableMembers(bluePrintClusterServices: List<BlueprintClusterService>) {
bluePrintClusterServices.forEach { bluePrintClusterService ->
val hazelcastClusterService = bluePrintClusterService as HazelcastClusterService
val hazelcast = hazelcastClusterService.hazelcast
import java.text.SimpleDateFormat
@RunWith(SpringRunner::class)
-class BluePrintMappingsTest {
+class BlueprintMappingsTest {
val formatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
val dateString = "2019-01-16T18:25:43.511Z"
package org.onap.ccsdk.cds.blueprintsprocessor.rest
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintRestLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
@Configuration
@ComponentScan
@EnableConfigurationProperties
-open class BluePrintRestLibConfiguration
+open class BlueprintRestLibConfiguration
/**
* Exposed Dependency Service by this Rest Lib Module
*/
-fun BluePrintDependencyService.restLibPropertyService(): BluePrintRestLibPropertyService =
+fun BlueprintDependencyService.restLibPropertyService(): BlueprintRestLibPropertyService =
instance(RestLibConstants.SERVICE_BLUEPRINT_REST_LIB_PROPERTY)
-fun BluePrintDependencyService.restClientService(selector: String): BlueprintWebClientService {
+fun BlueprintDependencyService.restClientService(selector: String): BlueprintWebClientService {
return restLibPropertyService().blueprintWebClientService(selector)
}
-fun BluePrintDependencyService.restClientService(jsonNode: JsonNode): BlueprintWebClientService {
+fun BlueprintDependencyService.restClientService(jsonNode: JsonNode): BlueprintWebClientService {
return restLibPropertyService().blueprintWebClientService(jsonNode)
}
package org.onap.ccsdk.cds.blueprintsprocessor.rest
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
/** Relationships Type DSL for Rest */
fun ServiceTemplateBuilder.relationshipTypeConnectsToRestClient() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToRestClient()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToRestClient()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToRestClient(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToRestClient(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship connects to through"
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
open class RestClientRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT, description
) {
fun basicAuth(block: BasicAuthRestClientPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.basicAuthRestClientProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.basicAuthRestClientProperties(block))
}
fun tokenAuth(block: TokenAuthRestClientPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.tokenAuthRestClientProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.tokenAuthRestClientProperties(block))
}
fun sslAuth(block: SslAuthRestClientPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.sslRestClientProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.sslRestClientProperties(block))
}
}
-fun BluePrintTypes.basicAuthRestClientProperties(block: BasicAuthRestClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.basicAuthRestClientProperties(block: BasicAuthRestClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = BasicAuthRestClientPropertiesAssignmentBuilder().apply(block).build()
assignments[RestClientProperties::type.name] = RestLibConstants.TYPE_BASIC_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.tokenAuthRestClientProperties(block: TokenAuthRestClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.tokenAuthRestClientProperties(block: TokenAuthRestClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = TokenAuthRestClientPropertiesAssignmentBuilder().apply(block).build()
assignments[RestClientProperties::type.name] = RestLibConstants.TYPE_TOKEN_AUTH.asJsonPrimitive()
return assignments.asJsonType()
}
-fun BluePrintTypes.sslRestClientProperties(block: SslAuthRestClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.sslRestClientProperties(block: SslAuthRestClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val assignments = SslAuthRestClientPropertiesAssignmentBuilder().apply(block).build()
assignments[RestClientProperties::type.name] = RestLibConstants.TYPE_SSL_NO_AUTH.asJsonPrimitive()
return assignments.asJsonType()
package org.onap.ccsdk.cds.blueprintsprocessor.rest.service
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.BasicAuthRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.PolicyManagerRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.RestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLTokenAuthRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.TokenAuthRestClientProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.stereotype.Service
@Service(RestLibConstants.SERVICE_BLUEPRINT_REST_LIB_PROPERTY)
-open class BluePrintRestLibPropertyService(private var bluePrintPropertiesService: BluePrintPropertiesService) {
+open class BlueprintRestLibPropertyService(private var bluePrintPropertiesService: BlueprintPropertiesService) {
private var preInterceptor: PreInterceptor? = null
private var postInterceptor: PostInterceptor? = null
policyManagerRestClientProperties(prefix)
}
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Rest adaptor($type) is" +
" not supported"
)
JacksonUtils.readValue(jsonNode, SSLRestClientProperties::class.java)!!
}
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"Rest adaptor($type) is not supported"
)
}
return BasicAuthRestClientService(restClientProperties)
}
else -> {
- throw BluePrintProcessorException("couldn't get rest service for type:${restClientProperties.type} uri: ${restClientProperties.url}")
+ throw BlueprintProcessorException("couldn't get rest service for type:${restClientProperties.type} uri: ${restClientProperties.url}")
}
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.rest.RestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.RestLibConstants
import org.onap.ccsdk.cds.blueprintsprocessor.rest.utils.WebClientUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintRetryException
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintIOUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintRetryException
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintIOUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpMethod
.build()
}
- /** High performance non blocking Retry function, If execution block [block] throws BluePrintRetryException
+ /** High performance non blocking Retry function, If execution block [block] throws BlueprintRetryException
* exception then this will perform wait and retrigger accoring to times [times] with delay [delay]
*/
suspend fun <T> retry(
block: suspend (Int) -> T
): T {
val exceptionBlock = { e: Exception ->
- if (e !is BluePrintRetryException) {
+ if (e !is BlueprintRetryException) {
throw e
}
}
- return BluePrintIOUtils.retry(times, initialDelay, delay, block, exceptionBlock)
+ return BlueprintIOUtils.retry(times, initialDelay, delay, block, exceptionBlock)
}
fun exchangeResource(methodType: String, path: String, request: String): WebClientResponse<String> {
HttpMethod.POST -> post(path, request, convertedHeaders, String::class.java)
HttpMethod.PUT -> put(path, request, convertedHeaders, String::class.java)
HttpMethod.PATCH -> patch(path, request, convertedHeaders, String::class.java)
- else -> throw BluePrintProcessorException(
+ else -> throw BlueprintProcessorException(
"Unsupported methodType($methodType) attempted on path($path)"
)
}
HttpMethod.DELETE -> deleteNB(path, convertedHeaders, responseType)
HttpMethod.PUT -> putNB(path, request, convertedHeaders, responseType)
HttpMethod.PATCH -> patchNB(path, request, convertedHeaders, responseType)
- else -> throw BluePrintProcessorException("Unsupported methodType($methodType)")
+ else -> throw BlueprintProcessorException("Unsupported methodType($methodType)")
}
}
" User-supplied \"additionalHeaders\" cannot contain AUTHORIZATION header with" +
" auth-type \"${RestLibConstants.TYPE_BASIC_AUTH}\""
WebClientUtils.log.error(errMsg)
- throw BluePrintProcessorException(errMsg)
+ throw BlueprintProcessorException(errMsg)
} else {
customHeaders.putAll(it)
}
import kotlinx.coroutines.reactor.asCoroutineContext
import kotlinx.coroutines.withContext
import org.apache.http.message.BasicHeader
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_INVOCATION_ID
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_ORIGINATOR_ID
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_PARTNER_NAME
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_REQUEST_ID
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.ONAP_SUBREQUEST_ID
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_INVOCATION_ID
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_ORIGINATOR_ID
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_PARTNER_NAME
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_REQUEST_ID
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.ONAP_SUBREQUEST_ID
import org.onap.ccsdk.cds.controllerblueprints.core.MDCContext
import org.onap.ccsdk.cds.controllerblueprints.core.defaultToEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.defaultToUUID
fun httpInvoking(headers: Array<BasicHeader>) {
headers.plusElement(BasicHeader(ONAP_REQUEST_ID, MDC.get("InvocationID").defaultToUUID()))
headers.plusElement(BasicHeader(ONAP_INVOCATION_ID, UUID.randomUUID().toString()))
- headers.plusElement(BasicHeader(ONAP_PARTNER_NAME, BluePrintConstants.APP_NAME))
+ headers.plusElement(BasicHeader(ONAP_PARTNER_NAME, BlueprintConstants.APP_NAME))
}
}
resHeaders[ONAP_SUBREQUEST_ID] = MDC.get("SubRequestID")
resHeaders[ONAP_ORIGINATOR_ID] = MDC.get("OriginatorID")
resHeaders[ONAP_INVOCATION_ID] = MDC.get("InvocationID")
- resHeaders[ONAP_PARTNER_NAME] = BluePrintConstants.APP_NAME
+ resHeaders[ONAP_PARTNER_NAME] = BlueprintConstants.APP_NAME
} catch (e: Exception) {
log.warn("couldn't set response headers", e)
} finally {
import com.fasterxml.jackson.databind.ObjectMapper
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.BluePrintRestLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.BlueprintRestLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLBasicAuthRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.SSLTokenAuthRestClientProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.http.HttpHeaders
import org.springframework.http.MediaType
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- BluePrintRestLibConfiguration::class, BluePrintPropertyConfiguration::class,
- BluePrintPropertiesService::class
+ BlueprintRestLibConfiguration::class, BlueprintPropertyConfiguration::class,
+ BlueprintPropertiesService::class
]
)
@TestPropertySource(
"blueprintsprocessor.restclient.ssl.sslKeyPassword=changeit"
]
)
-class BluePrintRestLibPropertyServiceTest {
+class BlueprintRestLibPropertyServiceTest {
@Autowired
- lateinit var bluePrintRestLibPropertyService: BluePrintRestLibPropertyService
+ lateinit var bluePrintRestLibPropertyService: BlueprintRestLibPropertyService
@Test
fun testRestClientProperties() {
additionalHeadersChangedContentTypeToAPPLICATION_XML(endPointWithHeadersJson)
}
- // called from within "assertFailsWith(exceptionClass = BluePrintProcessorException::class) {"
+ // called from within "assertFailsWith(exceptionClass = BlueprintProcessorException::class) {"
private fun attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson: String) {
val parsedObj: JsonNode = defaultMapper.readTree(endPointWithHeadersJson)
val bpWebClientService =
@Test
fun `BasicAuth WebClientService throws BlueprintProcessorException if additionalHeaders contain Authorization`() {
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
// spec says headers are case insensitive...
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = basicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
@Test
fun `TokenAuth WebClientService throws BlueprintProcessorException if additionalHeaders contain Authorization`() {
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuth)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
// spec says headers are case insensitive...
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = sslTokenAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
@Test
fun `SSLBasicAuth WebClientService throws BlueprintProcessorException if additionalHeaders contain Authorization`() {
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuth)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
// spec says headers are case insensitive...
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = sslBasicAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
@Test
fun `SSLNoAuth WebClientService throws BlueprintProcessorException if additionalHeaders contain Authorization`() {
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuth)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
// spec says headers are case insensitive...
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
val endPointWithHeadersJson = sslNoAuthEndpointWithHeadersField(additionalHeadersWithAuthLowercased)
attemptToPutAuthorizationHeaderIntoAdditionalHeaders(endPointWithHeadersJson)
}
}
- companion object BluePrintRestLibPropertyServiceTest {
+ companion object BlueprintRestLibPropertyServiceTest {
val defaultMapper = ObjectMapper()
val expectedTokenAuthDefaultHeaders = mapOf<String, String>(
import org.junit.Test
import org.onap.ccsdk.cds.blueprintsprocessor.rest.relationshipTemplateRestClient
import org.onap.ccsdk.cds.blueprintsprocessor.rest.relationshipTypeConnectsToRestClient
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.relationshipTypeConnectsTo
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
import kotlin.test.assertEquals
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_REST_CLIENT}"
)
}
}
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.rest.BluePrintRestLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.BlueprintRestLibConfiguration
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@ContextConfiguration(
classes = [
- BluePrintRestLibConfiguration::class, SampleController::class,
+ BlueprintRestLibConfiguration::class, SampleController::class,
SecurityConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
class RestClientServiceTest {
@Autowired
- lateinit var bluePrintRestLibPropertyService: BluePrintRestLibPropertyService
+ lateinit var bluePrintRestLibPropertyService: BlueprintRestLibPropertyService
@Autowired
lateinit var httpHandler: HttpHandler
package org.onap.ccsdk.cds.blueprintsprocessor.ssh
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.ssh.service.BluePrintSshLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.ssh.service.BlueprintSshLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.service.BlueprintSshClientService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
@Configuration
@ComponentScan
@EnableConfigurationProperties
-open class BluePrintSshLibConfiguration
+open class BlueprintSshLibConfiguration
/**
* Exposed Dependency Service by this SSH Lib Module
*/
-fun BluePrintDependencyService.sshLibPropertyService(): BluePrintSshLibPropertyService =
+fun BlueprintDependencyService.sshLibPropertyService(): BlueprintSshLibPropertyService =
instance(SshLibConstants.SERVICE_BLUEPRINT_SSH_LIB_PROPERTY)
-fun BluePrintDependencyService.sshClientService(selector: String): BlueprintSshClientService =
+fun BlueprintDependencyService.sshClientService(selector: String): BlueprintSshClientService =
sshLibPropertyService().blueprintSshClientService(selector)
-fun BluePrintDependencyService.sshClientService(jsonNode: JsonNode): BlueprintSshClientService =
+fun BlueprintDependencyService.sshClientService(jsonNode: JsonNode): BlueprintSshClientService =
sshLibPropertyService().blueprintSshClientService(jsonNode)
class SshLibConstants {
package org.onap.ccsdk.cds.blueprintsprocessor.ssh
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
/** Relationships Types DSL for Message Producer */
fun ServiceTemplateBuilder.relationshipTypeConnectsToSshClient() {
- val relationshipType = BluePrintTypes.relationshipTypeConnectsToSshClient()
+ val relationshipType = BlueprintTypes.relationshipTypeConnectsToSshClient()
if (this.relationshipTypes == null) this.relationshipTypes = hashMapOf()
this.relationshipTypes!![relationshipType.id!!] = relationshipType
}
-fun BluePrintTypes.relationshipTypeConnectsToSshClient(): RelationshipType {
+fun BlueprintTypes.relationshipTypeConnectsToSshClient(): RelationshipType {
return relationshipType(
- id = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT,
- version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
+ id = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT,
+ version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO,
description = "Relationship connects to through SSH Client."
) {
property(
- BluePrintConstants.PROPERTY_CONNECTION_CONFIG,
- BluePrintConstants.DATA_TYPE_MAP,
+ BlueprintConstants.PROPERTY_CONNECTION_CONFIG,
+ BlueprintConstants.DATA_TYPE_MAP,
true,
"Connection Config details."
)
- validTargetTypes(arrayListOf(BluePrintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
+ validTargetTypes(arrayListOf(BlueprintConstants.MODEL_TYPE_CAPABILITY_TYPE_ENDPOINT))
}
}
open class SshRelationshipTemplateBuilder(name: String, description: String) :
RelationshipTemplateBuilder(
name,
- BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT, description
+ BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT, description
) {
fun basicAuth(block: BasicAuthSshClientPropertiesAssignmentBuilder.() -> Unit) {
- property(BluePrintConstants.PROPERTY_CONNECTION_CONFIG, BluePrintTypes.basicAuthSshProperties(block))
+ property(BlueprintConstants.PROPERTY_CONNECTION_CONFIG, BlueprintTypes.basicAuthSshProperties(block))
}
}
-fun BluePrintTypes.basicAuthSshProperties(block: BasicAuthSshClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
+fun BlueprintTypes.basicAuthSshProperties(block: BasicAuthSshClientPropertiesAssignmentBuilder.() -> Unit): JsonNode {
val sshProperties = BasicAuthSshClientPropertiesAssignmentBuilder().apply(block).build()
sshProperties[SshClientProperties::type.name] = SshLibConstants.TYPE_BASIC_AUTH.asJsonPrimitive()
return sshProperties.asJsonType()
import org.apache.sshd.client.keyverifier.AcceptAllServerKeyVerifier
import org.apache.sshd.client.session.ClientSession
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BasicAuthSshClientProperties
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.slf4j.LoggerFactory
import java.io.ByteArrayOutputStream
import java.io.IOException
channel!!.err = ByteArrayOutputStream()
channel!!.open()
} catch (e: Exception) {
- throw BluePrintProcessorException("Failed to start Shell channel: ${e.message}")
+ throw BlueprintProcessorException("Failed to start Shell channel: ${e.message}")
}
}
}
}
} catch (e: Exception) {
- throw BluePrintProcessorException("Failed to execute commands, below the error message : ${e.message}")
+ throw BlueprintProcessorException("Failed to execute commands, below the error message : ${e.message}")
}
return response
}
teeOutput!!.flush()
deviceOutput = waitForPrompt(timeOut)
} catch (e: IOException) {
- throw BluePrintProcessorException("Exception during command execution: ${e.message}", e)
+ throw BlueprintProcessorException("Exception during command execution: ${e.message}", e)
}
if (detectFailure(deviceOutput)) {
Collections.unmodifiableSet(EnumSet.of(ClientChannelEvent.CLOSED)), timeOut
)
if (channel!!.out.toString().indexOfAny(arrayListOf("$", ">", "#")) <= 0 && waitMask.contains(ClientChannelEvent.TIMEOUT)) {
- throw BluePrintProcessorException("Timeout: Failed to retrieve commands result in $timeOut ms")
+ throw BlueprintProcessorException("Timeout: Failed to retrieve commands result in $timeOut ms")
}
val outputResult = channel!!.out.toString()
channel!!.out.flush()
package org.onap.ccsdk.cds.blueprintsprocessor.ssh.service
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BasicAuthSshClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.SshClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.SshLibConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.stereotype.Service
@Service(SshLibConstants.SERVICE_BLUEPRINT_SSH_LIB_PROPERTY)
-open class BluePrintSshLibPropertyService(private var bluePrintProperties: BluePrintPropertiesService) {
+open class BlueprintSshLibPropertyService(private var bluePrintProperties: BlueprintPropertiesService) {
fun blueprintSshClientService(jsonNode: JsonNode): BlueprintSshClientService {
val restClientProperties = sshClientProperties(jsonNode)
basicAuthSshClientProperties(prefix)
}
else -> {
- throw BluePrintProcessorException("SSH adaptor($type) is not supported")
+ throw BlueprintProcessorException("SSH adaptor($type) is not supported")
}
}
}
fun sshClientProperties(jsonNode: JsonNode): SshClientProperties {
val type = jsonNode.get("type")?.textValue()
- ?: throw BluePrintProcessorException("missing type field in ssh client properties")
+ ?: throw BlueprintProcessorException("missing type field in ssh client properties")
return when (type) {
SshLibConstants.TYPE_BASIC_AUTH -> {
JacksonUtils.readValue(
)!!
}
else -> {
- throw BluePrintProcessorException("SSH adaptor($type) is not supported")
+ throw BlueprintProcessorException("SSH adaptor($type) is not supported")
}
}
}
return BasicAuthSshClientService(sshClientProperties)
}
else -> {
- throw BluePrintProcessorException("couldn't get SSH client service for")
+ throw BlueprintProcessorException("couldn't get SSH client service for")
}
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.ssh
import org.junit.Test
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.relationshipTypeConnectsTo
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
import kotlin.test.assertEquals
assertNotNull(relationshipTypes, "failed to get relationship types")
assertEquals(2, relationshipTypes.size, "relationshipTypes doesn't match")
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO}"
)
assertNotNull(
- relationshipTypes[BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT],
- "failed to get ${BluePrintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT}"
+ relationshipTypes[BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT],
+ "failed to get ${BlueprintConstants.MODEL_TYPE_RELATIONSHIPS_CONNECTS_TO_SSH_CLIENT}"
)
}
}
import org.apache.sshd.server.session.ServerSession
import org.apache.sshd.server.shell.ProcessShellCommandFactory
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BluePrintSshLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BlueprintSshLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.service.echoShell.EchoShellFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- BluePrintSshLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintSshLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
class BlueprintSshClientServiceTest {
@Autowired
- lateinit var bluePrintSshLibPropertyService: BluePrintSshLibPropertyService
+ lateinit var bluePrintSshLibPropertyService: BlueprintSshLibPropertyService
- lateinit var bluePrintSshLibPropertyServiceMock: BluePrintSshLibPropertyService
+ lateinit var bluePrintSshLibPropertyServiceMock: BlueprintSshLibPropertyService
private lateinit var sshServer: SshServer
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BasicAuthSshClientProperties
-import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BluePrintSshLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.ssh.BlueprintSshLibConfiguration
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
import org.springframework.test.context.TestPropertySource
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- BluePrintSshLibConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class
+ BlueprintSshLibConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class
]
)
@TestPropertySource(
"blueprintsprocessor.sshclient.sample.username=dummy"
]
)
-class BluePrintSshLibPropertyServiceTest {
+class BlueprintSshLibPropertyServiceTest {
@Autowired
- lateinit var bluePrintSshLibPropertyService: BluePrintSshLibPropertyService
+ lateinit var bluePrintSshLibPropertyService: BlueprintSshLibPropertyService
@Test
fun testRestClientProperties() {
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest
@RunWith(SpringRunner::class)
@WebFluxTest
@ContextConfiguration(
- classes = [BluePrintCoreConfiguration::class, BluePrintCatalogService::class, ErrorCatalogTestConfiguration::class]
+ classes = [BlueprintCoreConfiguration::class, BlueprintCatalogService::class, ErrorCatalogTestConfiguration::class]
)
@ComponentScan(basePackages = ["org.onap.ccsdk.cds.blueprintsprocessor", "org.onap.ccsdk.cds.controllerblueprints"])
@TestPropertySource(locations = ["classpath:application-test.properties"])
package org.onap.ccsdk.cds.blueprintsprocessor.configs.api
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.PrimaryDatabaseConfiguration
import org.springframework.context.annotation.Bean
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = [
"org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution",
import com.google.protobuf.util.JsonFormat
import io.grpc.stub.StreamObserver
import kotlinx.coroutines.runBlocking
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.BluePrintModelHandler
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.BlueprintModelHandler
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.onap.ccsdk.cds.controllerblueprints.core.emptyTONull
import org.onap.ccsdk.cds.controllerblueprints.core.utils.currentTimestamp
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementServiceGrpc
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput
import org.onap.ccsdk.cds.controllerblueprints.management.api.DownloadAction
import org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk
import org.onap.ccsdk.cds.controllerblueprints.management.api.RemoveAction
// TODO("Convert to coroutines handler")
@Service
-open class BluePrintManagementGRPCHandler(
- private val bluePrintModelHandler: BluePrintModelHandler,
+open class BlueprintManagementGRPCHandler(
+ private val bluePrintModelHandler: BlueprintModelHandler,
private val errorCatalogService: ErrorCatalogService
) :
- BluePrintManagementServiceGrpc.BluePrintManagementServiceImplBase() {
+ BlueprintManagementServiceGrpc.BlueprintManagementServiceImplBase() {
- private val log = LoggerFactory.getLogger(BluePrintManagementGRPCHandler::class.java)
+ private val log = LoggerFactory.getLogger(BlueprintManagementGRPCHandler::class.java)
@PreAuthorize("hasRole('USER')")
override fun uploadBlueprint(
- request: BluePrintUploadInput,
- responseObserver: StreamObserver<BluePrintManagementOutput>
+ request: BlueprintUploadInput,
+ responseObserver: StreamObserver<BlueprintManagementOutput>
) {
runBlocking {
failStatus(
request.commonHeader,
"Upload action($uploadAction) not implemented",
- BluePrintProcessorException("Not Implemented")
+ BlueprintProcessorException("Not Implemented")
)
)
}
failStatus(
request.commonHeader,
"Upload action($uploadAction) not implemented",
- BluePrintProcessorException("Not implemented")
+ BlueprintProcessorException("Not implemented")
)
)
}
@PreAuthorize("hasRole('USER')")
override fun downloadBlueprint(
- request: BluePrintDownloadInput,
- responseObserver: StreamObserver<BluePrintManagementOutput>
+ request: BlueprintDownloadInput,
+ responseObserver: StreamObserver<BlueprintManagementOutput>
) {
runBlocking {
val blueprintName = request.actionIdentifiers.blueprintName
failStatus(
request.commonHeader,
"Search action($searchAction) not implemented",
- BluePrintProcessorException("Not implemented")
+ BlueprintProcessorException("Not implemented")
)
)
}
@PreAuthorize("hasRole('USER')")
override fun removeBlueprint(
- request: BluePrintRemoveInput,
+ request: BlueprintRemoveInput,
responseObserver:
- StreamObserver<BluePrintManagementOutput>
+ StreamObserver<BlueprintManagementOutput>
) {
runBlocking {
failStatus(
request.commonHeader,
"Remove action($removeAction) not implemented",
- BluePrintProcessorException("Not implemented")
+ BlueprintProcessorException("Not implemented")
)
)
}
}
override fun bootstrapBlueprint(
- request: BluePrintBootstrapInput,
- responseObserver: StreamObserver<BluePrintManagementOutput>
+ request: BlueprintBootstrapInput,
+ responseObserver: StreamObserver<BlueprintManagementOutput>
) {
runBlocking {
try {
}
}
- private fun outputWithFileBytes(header: CommonHeader, byteArray: ByteArray): BluePrintManagementOutput =
- BluePrintManagementOutput.newBuilder()
+ private fun outputWithFileBytes(header: CommonHeader, byteArray: ByteArray): BlueprintManagementOutput =
+ BlueprintManagementOutput.newBuilder()
.setCommonHeader(header)
.setFileChunk(FileChunk.newBuilder().setChunk(ByteString.copyFrom(byteArray)))
.setStatus(
Status.newBuilder()
.setTimestamp(currentTimestamp())
.setEventType(EventType.EVENT_COMPONENT_EXECUTED)
- .setMessage(BluePrintConstants.STATUS_SUCCESS)
+ .setMessage(BlueprintConstants.STATUS_SUCCESS)
.setCode(200)
.build()
)
.build()
- private fun successStatus(header: CommonHeader, propertyContent: String? = null): BluePrintManagementOutput {
+ private fun successStatus(header: CommonHeader, propertyContent: String? = null): BlueprintManagementOutput {
// Populate Response Payload
- val propertiesBuilder = BluePrintManagementOutput.newBuilder().propertiesBuilder
+ val propertiesBuilder = BlueprintManagementOutput.newBuilder().propertiesBuilder
propertyContent?.let {
JsonFormat.parser().merge(propertyContent, propertiesBuilder)
}
- return BluePrintManagementOutput.newBuilder()
+ return BlueprintManagementOutput.newBuilder()
.setCommonHeader(header)
.setProperties(propertiesBuilder.build())
.setStatus(
Status.newBuilder()
.setTimestamp(currentTimestamp())
- .setMessage(BluePrintConstants.STATUS_SUCCESS)
+ .setMessage(BlueprintConstants.STATUS_SUCCESS)
.setEventType(EventType.EVENT_COMPONENT_EXECUTED)
.setCode(200)
.build()
.build()
}
- private fun failStatus(header: CommonHeader, message: String, e: Exception): BluePrintManagementOutput {
+ private fun failStatus(header: CommonHeader, message: String, e: Exception): BlueprintManagementOutput {
log.error(message, e)
- return if (e is BluePrintProcessorException) onErrorCatalog(header, message, e) else onError(header, message, e)
+ return if (e is BlueprintProcessorException) onErrorCatalog(header, message, e) else onError(header, message, e)
}
- private fun onError(header: CommonHeader, message: String, error: Exception): BluePrintManagementOutput {
+ private fun onError(header: CommonHeader, message: String, error: Exception): BlueprintManagementOutput {
val code = GrpcErrorCodes.code(ErrorCatalogCodes.GENERIC_FAILURE)
- return BluePrintManagementOutput.newBuilder()
+ return BlueprintManagementOutput.newBuilder()
.setCommonHeader(header)
.setStatus(
Status.newBuilder()
.setTimestamp(currentTimestamp())
- .setMessage(BluePrintConstants.STATUS_FAILURE)
+ .setMessage(BlueprintConstants.STATUS_FAILURE)
.setEventType(EventType.EVENT_COMPONENT_FAILURE)
.setErrorMessage("Error : $message \n Details: ${error.errorMessageOrDefault()}")
.setCode(code)
.build()
}
- private fun onErrorCatalog(header: CommonHeader, message: String, error: BluePrintProcessorException):
- BluePrintManagementOutput {
+ private fun onErrorCatalog(header: CommonHeader, message: String, error: BlueprintProcessorException):
+ BlueprintManagementOutput {
val err = if (error.protocol == "") {
error.grpc(ErrorCatalogCodes.GENERIC_FAILURE)
} else {
error.convertToGrpc()
}
val errorPayload = errorCatalogService.errorPayload(err.addErrorPayloadMessage(message))
- return BluePrintManagementOutput.newBuilder()
+ return BlueprintManagementOutput.newBuilder()
.setCommonHeader(header)
.setStatus(
Status.newBuilder()
.setTimestamp(currentTimestamp())
- .setMessage(BluePrintConstants.STATUS_FAILURE)
+ .setMessage(BlueprintConstants.STATUS_FAILURE)
.setEventType(EventType.EVENT_COMPONENT_FAILURE)
.setErrorMessage("Error : ${errorPayload.message}")
.setCode(errorPayload.code)
import io.swagger.annotations.ApiResponses
import org.jetbrains.annotations.NotNull
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.domain.BlueprintModelSearch
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.BluePrintModelHandler
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.BlueprintModelHandler
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintSortByOption
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.mdcWebCoroutineScope
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
import org.springframework.core.io.Resource
import org.springframework.data.domain.Page
value = "Blueprint Model Catalog",
description = "Manages all blueprint models which are available in CDS"
)
-open class BlueprintModelController(private val bluePrintModelHandler: BluePrintModelHandler) {
+open class BlueprintModelController(private val bluePrintModelHandler: BlueprintModelHandler) {
@PostMapping(
path = arrayOf("/bootstrap"), produces = arrayOf(MediaType.APPLICATION_JSON_VALUE),
ApiResponse(code = 500, message = "Internal Server Error")
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun bootstrap(
@ApiParam(required = true, value = "Specifies which elements to load")
ApiResponse(code = 500, message = "Internal Server Error")
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun saveBlueprint(
@ApiParam(name = "file", value = "CBA file to be uploaded (example: cba.zip)", required = true)
@PathVariable(value = "keyword") keyWord: String
): List<BlueprintModelSearch> =
mdcWebCoroutineScope {
- bluePrintModelHandler.searchBluePrintModelsByKeyWord(keyWord)
+ bluePrintModelHandler.searchBlueprintModelsByKeyWord(keyWord)
}
@GetMapping("/paged/meta-data/{keyword}", produces = [MediaType.APPLICATION_JSON_VALUE])
offset, limit,
Sort.Direction.fromString(sortType), sort.columnName
)
- return this.bluePrintModelHandler.searchBluePrintModelsByKeyWordPaged(keyWord, pageRequest)
+ return this.bluePrintModelHandler.searchBlueprintModelsByKeyWordPaged(keyWord, pageRequest)
}
@DeleteMapping("/{id}")
ApiResponse(code = 200, message = "OK"),
ApiResponse(code = 404, message = "RESOURCE_NOT_FOUND")
)
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun deleteBlueprint(
@ApiParam(value = "ID of the blueprint model to delete", required = true, example = "67ec1f96-ab55-4b81-aff9-23ee0ed1d7a4")
ApiResponse(code = 404, message = "Not Found")
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun getBlueprintByNameAndVersion(
@ApiParam(value = "Name of the blueprint model", required = true, example = "pnf_netconf") @PathVariable(value = "name") name: String,
ApiResponse(code = 404, message = "Not Found")
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun downloadBlueprintByNameAndVersion(
@ApiParam(value = "Name of the blueprint model", required = true, example = "pnf_netconf") @PathVariable(value = "name") name: String,
ApiResponse(code = 404, message = "Not Found")
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun getBlueprintModel(
@ApiParam(value = "ID of the blueprint model to search for", required = true, example = "67ec1f96-ab55-4b81-aff9-23ee0ed1d7a4")
ApiResponse(code = 404, message = "Not Found")
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
- suspend fun downloadBluePrint(
+ suspend fun downloadBlueprint(
@ApiParam(value = "ID of the blueprint model to download", required = true, example = "67ec1f96-ab55-4b81-aff9-23ee0ed1d7a4")
@PathVariable(value = "id") id: String
): ResponseEntity<Resource> =
"The enrichment process will complete the package by providing all the definition of types used."
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun enrichBlueprint(
@ApiParam(name = "file", value = "CBA zip file to be uploaded (example: cba_unenriched.zip)", required = true)
ApiResponse(code = 503, message = "Service Unavailable")
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun enrichAndPubishlueprint(
@ApiParam(name = "file", value = "Unenriched CBA zip file to be uploaded (example: cba_unenriched.zip)", required = true)
response = BlueprintModelSearch::class
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun publishBlueprint(
@ApiParam(name = "file", value = "Enriched CBA zip file to be uploaded (example: cba_enriched.zip)", required = true)
"Inputs, outputs and data types of workflow is returned."
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun workflowSpec(
@ApiParam(required = true, value = "Blueprint and workflow identification")
notes = "Get all available workflows of a Blueprint identified by its name and version."
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
@PreAuthorize("hasRole('USER')")
suspend fun getWorkflowList(
@ApiParam(value = "Name of the blueprint model", example = "pnf_netconf", required = true)
import io.swagger.annotations.ApiModel
import io.swagger.annotations.ApiModelProperty
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ResourceDictionary
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.DATA_TYPE_JSON
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.DEFAULT_VERSION_NUMBER
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants.TOSCA_SPEC
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.DATA_TYPE_JSON
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.DEFAULT_VERSION_NUMBER
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants.TOSCA_SPEC
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ModelType
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.ModelTypeHandler
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.mdcWebCoroutineScope
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.springframework.http.MediaType
import org.springframework.web.bind.annotation.DeleteMapping
import org.springframework.web.bind.annotation.GetMapping
response = ModelType::class
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun saveModelType(@RequestBody modelType: ModelType): ModelType = mdcWebCoroutineScope {
modelTypeHandler.saveModel(modelType)
}
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ResourceDictionary
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.ResourceDictionaryHandler
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.mdcWebCoroutineScope
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceSourceMapping
import org.springframework.http.MediaType
response = ResourceDictionary::class
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun getResourceDictionaryByName(
@ApiParam(value = "Name of the resource", required = true, example = "\"hostname\"")
@PathVariable(value = "name") name: String
response = ResourceDictionary::class
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun saveResourceDictionary(
@ApiParam(value = "Resource dictionary to store", required = true)
@RequestBody dataDictionary: ResourceDictionary
response = ResourceDefinition::class
)
@ResponseBody
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun saveResourceDictionary(
@ApiParam(value = "Resource definition to generate", required = true)
@RequestBody resourceDefinition: ResourceDefinition
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactDefinitionEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.springframework.stereotype.Service
@Service
-open class BluePrintArtifactDefinitionEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
+open class BlueprintArtifactDefinitionEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService,
private val resourceAssignmentEnhancerService: ResourceAssignmentEnhancerService
) :
- BluePrintArtifactDefinitionEnhancer {
+ BlueprintArtifactDefinitionEnhancer {
companion object {
const val ARTIFACT_TYPE_MAPPING_SOURCE: String = "artifact-mapping-resource"
}
- private val log = logger(BluePrintArtifactDefinitionEnhancerImpl::class)
+ private val log = logger(BlueprintArtifactDefinitionEnhancerImpl::class)
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, artifactDefinition: ArtifactDefinition) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, artifactDefinition: ArtifactDefinition) {
log.info("enhancing ArtifactDefinition($name)")
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
val artifactTypeName = artifactDefinition.type
- ?: throw BluePrintException("artifact type is missing for ArtifactDefinition($name)")
+ ?: throw BlueprintException("artifact type is missing for ArtifactDefinition($name)")
// Populate Artifact Type
- BluePrintEnhancerUtils.populateArtifactType(bluePrintContext, bluePrintRepoService, artifactTypeName)
+ BlueprintEnhancerUtils.populateArtifactType(bluePrintContext, bluePrintRepoService, artifactTypeName)
when (artifactTypeName) {
ARTIFACT_TYPE_MAPPING_SOURCE -> {
if (!alreadyEnhanced) {
val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromFile(artifactFilePath, ResourceAssignment::class.java)
as? MutableList<ResourceAssignment>
- ?: throw BluePrintProcessorException("couldn't get ResourceAssignment definitions for the file($artifactFilePath)")
+ ?: throw BlueprintProcessorException("couldn't get ResourceAssignment definitions for the file($artifactFilePath)")
// Call Resource Assignment Enhancer
- resourceAssignmentEnhancerService.enhanceBluePrint(bluePrintTypeEnhancerService, bluePrintRuntimeService, resourceAssignments)
+ resourceAssignmentEnhancerService.enhanceBlueprint(bluePrintTypeEnhancerService, bluePrintRuntimeService, resourceAssignments)
bluePrintRuntimeService.put(alreadyEnhancedKey, true.asJsonPrimitive())
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.AttributeDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintAttributeDefinitionEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintAttributeDefinitionEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
-class BluePrintAttributeDefinitionEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
+class BlueprintAttributeDefinitionEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
) :
- BluePrintAttributeDefinitionEnhancer {
+ BlueprintAttributeDefinitionEnhancer {
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, attributeDefinition: AttributeDefinition) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, attributeDefinition: AttributeDefinition) {
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
val propertyType = attributeDefinition.type
- if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {
- } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {
+ if (BlueprintTypes.validPrimitiveTypes().contains(propertyType)) {
+ } else if (BlueprintTypes.validCollectionTypes().contains(propertyType)) {
val entrySchema = attributeDefinition.entrySchema
- ?: throw BluePrintException("Entry Schema is missing for collection property($name)")
+ ?: throw BlueprintException("Entry Schema is missing for collection property($name)")
- if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {
- BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, entrySchema.type)
+ if (!BlueprintTypes.validPrimitiveTypes().contains(entrySchema.type)) {
+ BlueprintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, entrySchema.type)
}
} else {
- BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, propertyType)
+ BlueprintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, propertyType)
}
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.DesignerApiDomains
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.httpProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.onap.ccsdk.cds.controllerblueprints.core.updateErrorMessage
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintFileUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintFileUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils.ResourceDictionaryUtils
import org.onap.ccsdk.cds.error.catalog.core.ErrorCatalogCodes
import org.onap.ccsdk.cds.error.catalog.core.utils.errorCauseOrDefault
import java.util.UUID
@Service
-open class BluePrintEnhancerServiceImpl(
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
+open class BlueprintEnhancerServiceImpl(
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService,
private val resourceDefinitionEnhancerService: ResourceDefinitionEnhancerService
-) : BluePrintEnhancerService {
+) : BlueprintEnhancerService {
- private val log = logger(BluePrintEnhancerServiceImpl::class)
+ private val log = logger(BlueprintEnhancerServiceImpl::class)
- override suspend fun enhance(basePath: String, enrichedBasePath: String): BluePrintContext {
+ override suspend fun enhance(basePath: String, enrichedBasePath: String): BlueprintContext {
// Copy the Blueprint Content to Target Location
- BluePrintFileUtils.copyBluePrint(basePath, enrichedBasePath)
+ BlueprintFileUtils.copyBlueprint(basePath, enrichedBasePath)
// Enhance the Blueprint
return enhance(enrichedBasePath)
}
- @Throws(BluePrintException::class)
- override suspend fun enhance(basePath: String): BluePrintContext {
+ @Throws(BlueprintException::class)
+ override suspend fun enhance(basePath: String): BlueprintContext {
log.info("Enhancing blueprint($basePath)")
- val blueprintRuntimeService = BluePrintMetadataUtils
- .getBaseEnhancementBluePrintRuntime(UUID.randomUUID().toString(), basePath)
+ val blueprintRuntimeService = BlueprintMetadataUtils
+ .getBaseEnhancementBlueprintRuntime(UUID.randomUUID().toString(), basePath)
try {
)
// Write the Enhanced Blueprint Definitions
- BluePrintFileUtils.writeEnhancedBluePrint(blueprintRuntimeService.bluePrintContext())
+ BlueprintFileUtils.writeEnhancedBlueprint(blueprintRuntimeService.bluePrintContext())
// Write the Enhanced Blueprint Resource Definitions
ResourceDictionaryUtils.writeResourceDefinitionTypes(basePath, resourceDefinitions)
- if (blueprintRuntimeService.getBluePrintError().errors.isNotEmpty()) {
- throw BluePrintException(blueprintRuntimeService.getBluePrintError().errors.toString())
+ if (blueprintRuntimeService.getBlueprintError().errors.isNotEmpty()) {
+ throw BlueprintException(blueprintRuntimeService.getBlueprintError().errors.toString())
}
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Error while enriching the CBA package."
throw e.updateErrorMessage(
DesignerApiDomains.DESIGNER_API, errorMsg,
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintNodeTemplateEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
+open class BlueprintNodeTemplateEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
) :
- BluePrintNodeTemplateEnhancer {
+ BlueprintNodeTemplateEnhancer {
- private val log = logger(BluePrintNodeTemplateEnhancerImpl::class)
+ private val log = logger(BlueprintNodeTemplateEnhancerImpl::class)
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
log.info("***** Enhancing NodeTemplate($name)")
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
val nodeTypeName = nodeTemplate.type
// Get NodeType from Repo and Update Service Template
- val nodeType = BluePrintEnhancerUtils.populateNodeType(bluePrintContext, bluePrintRepoService, nodeTypeName)
+ val nodeType = BlueprintEnhancerUtils.populateNodeType(bluePrintContext, bluePrintRepoService, nodeTypeName)
// Enrich NodeType
bluePrintTypeEnhancerService.enhanceNodeType(bluePrintRuntimeService, nodeTypeName, nodeType)
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.OperationDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTypeEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTypeEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintNodeTypeEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
-) : BluePrintNodeTypeEnhancer {
+open class BlueprintNodeTypeEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
+) : BlueprintNodeTypeEnhancer {
- private val log = logger(BluePrintNodeTypeEnhancerImpl::class)
+ private val log = logger(BlueprintNodeTypeEnhancerImpl::class)
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeType: NodeType) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, nodeType: NodeType) {
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
val derivedFrom = nodeType.derivedFrom
- if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {
- val derivedFromNodeType = BluePrintEnhancerUtils.populateNodeType(bluePrintContext, bluePrintRepoService, name)
+ if (!BlueprintTypes.rootNodeTypes().contains(derivedFrom)) {
+ val derivedFromNodeType = BlueprintEnhancerUtils.populateNodeType(bluePrintContext, bluePrintRepoService, name)
// Enrich NodeType
enhance(bluePrintRuntimeService, derivedFrom, derivedFromNodeType)
}
// Populate Requirement Node
requirementDefinition.node?.let { requirementNodeTypeName ->
// Get Requirement NodeType from Repo and Update Service Template
- val requirementNodeType = BluePrintEnhancerUtils.populateNodeType(
+ val requirementNodeType = BlueprintEnhancerUtils.populateNodeType(
bluePrintContext,
bluePrintRepoService, requirementNodeTypeName
)
// Enhance Relationship Type
val relationShipTypeName = requirementDefinition.relationship
- ?: throw BluePrintException(
+ ?: throw BlueprintException(
"couldn't get relationship name for the NodeType($nodeTypeName) " +
"Requirement($requirementName)"
)
* Get the Relationship Type from database and add to Blueprint Context
*/
open fun enrichRelationShipType(relationshipName: String) {
- BluePrintEnhancerUtils.populateRelationshipType(bluePrintContext, bluePrintRepoService, relationshipName)
+ BlueprintEnhancerUtils.populateRelationshipType(bluePrintContext, bluePrintRepoService, relationshipName)
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
import org.onap.ccsdk.cds.controllerblueprints.core.data.PolicyType
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintPolicyTypeEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintPolicyTypeEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-class BluePrintPolicyTypeEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
+class BlueprintPolicyTypeEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
) :
- BluePrintPolicyTypeEnhancer {
+ BlueprintPolicyTypeEnhancer {
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: PolicyType) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, type: PolicyType) {
this.bluePrintRuntimeService = bluePrintRuntimeService
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintPropertyDefinitionEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintPropertyDefinitionEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintPropertyDefinitionEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
+open class BlueprintPropertyDefinitionEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
) :
- BluePrintPropertyDefinitionEnhancer {
+ BlueprintPropertyDefinitionEnhancer {
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, propertyDefinition: PropertyDefinition) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, propertyDefinition: PropertyDefinition) {
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
val propertyType = propertyDefinition.type
- if (BluePrintTypes.validPrimitiveTypes().contains(propertyType) ||
- BluePrintTypes.validComplexTypes().contains(propertyType)
+ if (BlueprintTypes.validPrimitiveTypes().contains(propertyType) ||
+ BlueprintTypes.validComplexTypes().contains(propertyType)
) {
// Do Nothing,
- } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {
+ } else if (BlueprintTypes.validCollectionTypes().contains(propertyType)) {
val entrySchema = propertyDefinition.entrySchema
- ?: throw BluePrintException("Entry Schema is missing for collection property($name)")
+ ?: throw BlueprintException("Entry Schema is missing for collection property($name)")
- if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {
- BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, entrySchema.type)
+ if (!BlueprintTypes.validPrimitiveTypes().contains(entrySchema.type)) {
+ BlueprintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, entrySchema.type)
}
} else {
- BluePrintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, propertyType)
+ BlueprintEnhancerUtils.populateDataTypes(bluePrintContext, bluePrintRepoService, propertyType)
}
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRelationshipTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRelationshipTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintRelationshipTemplateEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
+open class BlueprintRelationshipTemplateEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
) :
- BluePrintRelationshipTemplateEnhancer {
+ BlueprintRelationshipTemplateEnhancer {
- private val log = logger(BluePrintRelationshipTemplateEnhancerImpl::class)
+ private val log = logger(BlueprintRelationshipTemplateEnhancerImpl::class)
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
override fun enhance(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
relationshipTemplate: RelationshipTemplate
) {
val relationshipTypeName = relationshipTemplate.type
// Get RelationshipType from Repo and Update Service Template
val relationshipType =
- BluePrintEnhancerUtils.populateRelationshipType(
+ BlueprintEnhancerUtils.populateRelationshipType(
bluePrintContext,
bluePrintRepoService,
relationshipTypeName
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRelationshipTypeEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRelationshipTypeEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintRelationshipTypeEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
-) : BluePrintRelationshipTypeEnhancer {
+open class BlueprintRelationshipTypeEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
+) : BlueprintRelationshipTypeEnhancer {
- private val log = logger(BluePrintRelationshipTypeEnhancerImpl::class)
+ private val log = logger(BlueprintRelationshipTypeEnhancerImpl::class)
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
override fun enhance(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
name: String,
relationshipType: RelationshipType
) {
val derivedFrom = relationshipType.derivedFrom
- if (!BluePrintTypes.rootRelationshipTypes().contains(derivedFrom)) {
+ if (!BlueprintTypes.rootRelationshipTypes().contains(derivedFrom)) {
val derivedFromRelationshipType =
- BluePrintEnhancerUtils.populateRelationshipType(bluePrintContext, bluePrintRepoService, name)
+ BlueprintEnhancerUtils.populateRelationshipType(bluePrintContext, bluePrintRepoService, name)
// Enrich RelationshipType
enhance(bluePrintRuntimeService, derivedFrom, derivedFromRelationshipType)
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintServiceTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintServiceTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintServiceTemplateEnhancerImpl(private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService) :
- BluePrintServiceTemplateEnhancer {
+open class BlueprintServiceTemplateEnhancerImpl(private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService) :
+ BlueprintServiceTemplateEnhancer {
- private val log = logger(BluePrintServiceTemplateEnhancerImpl::class)
+ private val log = logger(BlueprintServiceTemplateEnhancerImpl::class)
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: ServiceTemplate) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, type: ServiceTemplate) {
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTopologyTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTopologyTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Service
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintTopologyTemplateEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService
+open class BlueprintTopologyTemplateEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService
) :
- BluePrintTopologyTemplateEnhancer {
+ BlueprintTopologyTemplateEnhancer {
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, type: TopologyTemplate) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, type: TopologyTemplate) {
this.bluePrintRuntimeService = bluePrintRuntimeService
enhanceTopologyTemplateInputs(type)
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintArtifactDefinitionEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintAttributeDefinitionEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTypeEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintPolicyTypeEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintPropertyDefinitionEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRelationshipTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRelationshipTypeEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintServiceTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTopologyTemplateEnhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintArtifactDefinitionEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintAttributeDefinitionEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTypeEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintPolicyTypeEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintPropertyDefinitionEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRelationshipTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRelationshipTypeEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintServiceTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTopologyTemplateEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowEnhancer
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationContext
import org.springframework.stereotype.Service
@Service
-open class BluePrintTypeEnhancerServiceImpl : BluePrintTypeEnhancerService {
+open class BlueprintTypeEnhancerServiceImpl : BlueprintTypeEnhancerService {
@Autowired
private lateinit var context: ApplicationContext
- override fun getServiceTemplateEnhancers(): List<BluePrintServiceTemplateEnhancer> {
- return context.getBeansOfType(BluePrintServiceTemplateEnhancer::class.java).map { it.value }
+ override fun getServiceTemplateEnhancers(): List<BlueprintServiceTemplateEnhancer> {
+ return context.getBeansOfType(BlueprintServiceTemplateEnhancer::class.java).map { it.value }
}
- override fun getTopologyTemplateEnhancers(): List<BluePrintTopologyTemplateEnhancer> {
- return context.getBeansOfType(BluePrintTopologyTemplateEnhancer::class.java).map { it.value }
+ override fun getTopologyTemplateEnhancers(): List<BlueprintTopologyTemplateEnhancer> {
+ return context.getBeansOfType(BlueprintTopologyTemplateEnhancer::class.java).map { it.value }
}
- override fun getWorkflowEnhancers(): List<BluePrintWorkflowEnhancer> {
- return context.getBeansOfType(BluePrintWorkflowEnhancer::class.java).map { it.value }
+ override fun getWorkflowEnhancers(): List<BlueprintWorkflowEnhancer> {
+ return context.getBeansOfType(BlueprintWorkflowEnhancer::class.java).map { it.value }
}
- override fun getNodeTemplateEnhancers(): List<BluePrintNodeTemplateEnhancer> {
- return context.getBeansOfType(BluePrintNodeTemplateEnhancer::class.java).map { it.value }
+ override fun getNodeTemplateEnhancers(): List<BlueprintNodeTemplateEnhancer> {
+ return context.getBeansOfType(BlueprintNodeTemplateEnhancer::class.java).map { it.value }
}
- override fun getNodeTypeEnhancers(): List<BluePrintNodeTypeEnhancer> {
- return context.getBeansOfType(BluePrintNodeTypeEnhancer::class.java).map { it.value }
+ override fun getNodeTypeEnhancers(): List<BlueprintNodeTypeEnhancer> {
+ return context.getBeansOfType(BlueprintNodeTypeEnhancer::class.java).map { it.value }
}
- override fun getRelationshipTemplateEnhancers(): List<BluePrintRelationshipTemplateEnhancer> {
- return context.getBeansOfType(BluePrintRelationshipTemplateEnhancer::class.java).map { it.value }
+ override fun getRelationshipTemplateEnhancers(): List<BlueprintRelationshipTemplateEnhancer> {
+ return context.getBeansOfType(BlueprintRelationshipTemplateEnhancer::class.java).map { it.value }
}
- override fun getRelationshipTypeEnhancers(): List<BluePrintRelationshipTypeEnhancer> {
- return context.getBeansOfType(BluePrintRelationshipTypeEnhancer::class.java).map { it.value }
+ override fun getRelationshipTypeEnhancers(): List<BlueprintRelationshipTypeEnhancer> {
+ return context.getBeansOfType(BlueprintRelationshipTypeEnhancer::class.java).map { it.value }
}
- override fun getArtifactDefinitionEnhancers(): List<BluePrintArtifactDefinitionEnhancer> {
- return context.getBeansOfType(BluePrintArtifactDefinitionEnhancer::class.java).map { it.value }
+ override fun getArtifactDefinitionEnhancers(): List<BlueprintArtifactDefinitionEnhancer> {
+ return context.getBeansOfType(BlueprintArtifactDefinitionEnhancer::class.java).map { it.value }
}
- override fun getPolicyTypeEnhancers(): List<BluePrintPolicyTypeEnhancer> {
- return context.getBeansOfType(BluePrintPolicyTypeEnhancer::class.java).map { it.value }
+ override fun getPolicyTypeEnhancers(): List<BlueprintPolicyTypeEnhancer> {
+ return context.getBeansOfType(BlueprintPolicyTypeEnhancer::class.java).map { it.value }
}
- override fun getPropertyDefinitionEnhancers(): List<BluePrintPropertyDefinitionEnhancer> {
- return context.getBeansOfType(BluePrintPropertyDefinitionEnhancer::class.java).map { it.value }
+ override fun getPropertyDefinitionEnhancers(): List<BlueprintPropertyDefinitionEnhancer> {
+ return context.getBeansOfType(BlueprintPropertyDefinitionEnhancer::class.java).map { it.value }
}
- override fun getAttributeDefinitionEnhancers(): List<BluePrintAttributeDefinitionEnhancer> {
- return context.getBeansOfType(BluePrintAttributeDefinitionEnhancer::class.java).map { it.value }
+ override fun getAttributeDefinitionEnhancers(): List<BlueprintAttributeDefinitionEnhancer> {
+ return context.getBeansOfType(BlueprintAttributeDefinitionEnhancer::class.java).map { it.value }
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowEnhancer
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowEnhancer
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.springframework.beans.factory.config.ConfigurableBeanFactory
@Service
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class BluePrintWorkflowEnhancerImpl(
- private val bluePrintRepoService: BluePrintRepoService,
- private val bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
+open class BlueprintWorkflowEnhancerImpl(
+ private val bluePrintRepoService: BlueprintRepoService,
+ private val bluePrintTypeEnhancerService: BlueprintTypeEnhancerService,
private val resourceAssignmentEnhancerService: ResourceAssignmentEnhancerService
) :
- BluePrintWorkflowEnhancer {
+ BlueprintWorkflowEnhancer {
- private val log = logger(BluePrintWorkflowEnhancerImpl::class)
+ private val log = logger(BlueprintWorkflowEnhancerImpl::class)
companion object {
const val PROPERTY_DEPENDENCY_NODE_TEMPLATES = "dependency-node-templates"
}
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintContext: BluePrintContext
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintContext: BlueprintContext
private val workflowDataTypes: MutableMap<String, DataType> = hashMapOf()
- override fun enhance(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, workflow: Workflow) {
+ override fun enhance(bluePrintRuntimeService: BlueprintRuntimeService<*>, name: String, workflow: Workflow) {
log.info("##### Enhancing Workflow($name)")
this.bluePrintRuntimeService = bluePrintRuntimeService
this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
val derivedFrom = bluePrintContext.nodeTemplateNodeType(firstNodeTemplateName).derivedFrom
when {
- derivedFrom.startsWith(BluePrintConstants.MODEL_TYPE_NODE_COMPONENT, true) -> {
+ derivedFrom.startsWith(BlueprintConstants.MODEL_TYPE_NODE_COMPONENT, true) -> {
enhanceStepTargets(name, workflow, firstNodeTemplateName, false)
}
- derivedFrom.startsWith(BluePrintConstants.MODEL_TYPE_NODE_WORKFLOW, true) -> {
+ derivedFrom.startsWith(BlueprintConstants.MODEL_TYPE_NODE_WORKFLOW, true) -> {
enhanceStepTargets(name, workflow, firstNodeTemplateName, true)
}
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"couldn't execute workflow($name) step mapped " +
"to node template($firstNodeTemplateName) derived from($derivedFrom)"
)
// Get the Dependent Component Node Template Names
val dependencyNodeTemplateNodes = dgNodeTemplate.properties?.get(PROPERTY_DEPENDENCY_NODE_TEMPLATES)
- ?: throw BluePrintException("couldn't get property($PROPERTY_DEPENDENCY_NODE_TEMPLATES) ")
+ ?: throw BlueprintException("couldn't get property($PROPERTY_DEPENDENCY_NODE_TEMPLATES) ")
dependencyNodeTemplates =
JacksonUtils.getListFromJsonNode(dependencyNodeTemplateNodes, String::class.java)
val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromFile(filePath, ResourceAssignment::class.java)
as? MutableList<ResourceAssignment>
- ?: throw BluePrintProcessorException("couldn't get ResourceAssignment definitions for the file($filePath)")
+ ?: throw BlueprintProcessorException("couldn't get ResourceAssignment definitions for the file($filePath)")
val alreadyEnhancedKey = "enhanced-$fileName"
val alreadyEnhanced = bluePrintRuntimeService.check(alreadyEnhancedKey)
if (!alreadyEnhanced) {
// Call Resource Assignment Enhancer
- resourceAssignmentEnhancerService.enhanceBluePrint(bluePrintTypeEnhancerService, bluePrintRuntimeService, resourceAssignments)
+ resourceAssignmentEnhancerService.enhanceBlueprint(bluePrintTypeEnhancerService, bluePrintRuntimeService, resourceAssignments)
bluePrintRuntimeService.put(alreadyEnhancedKey, true.asJsonPrimitive())
}
dynamicDataType = DataType()
dynamicDataType.version = "1.0.0"
dynamicDataType.description = "Dynamic DataType definition for workflow($workflowName)."
- dynamicDataType.derivedFrom = BluePrintConstants.MODEL_TYPE_DATA_TYPE_DYNAMIC
+ dynamicDataType.derivedFrom = BlueprintConstants.MODEL_TYPE_DATA_TYPE_DYNAMIC
val dataTypeProperties: MutableMap<String, PropertyDefinition> = hashMapOf()
dynamicDataType.properties = dataTypeProperties
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.enhancer
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.service.ResourceDefinitionRepoService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDictionaryConstants
*/
interface ResourceAssignmentEnhancerService {
- @Throws(BluePrintException::class)
- fun enhanceBluePrint(
- bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ @Throws(BlueprintException::class)
+ fun enhanceBlueprint(
+ bluePrintTypeEnhancerService: BlueprintTypeEnhancerService,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
resourceAssignments: List<ResourceAssignment>
)
}
* Get the defined source instance from the ResourceAssignment,
* then get the NodeType of the Sources assigned
*/
- override fun enhanceBluePrint(
- bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ override fun enhanceBlueprint(
+ bluePrintTypeEnhancerService: BlueprintTypeEnhancerService,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
resourceAssignments: List<ResourceAssignment>
) {
val resourceDefinition: ResourceDefinition = getResourceDefinition(dictionaryName)
val sourceNodeTemplate = resourceDefinition.sources[dictionarySource]
- ?: throw BluePrintException("failed to get assigned dictionarySource($dictionarySource) from resourceDefinition($dictionaryName)")
+ ?: throw BlueprintException("failed to get assigned dictionarySource($dictionarySource) from resourceDefinition($dictionaryName)")
// Enrich as NodeTemplate
bluePrintTypeEnhancerService.enhanceNodeTemplate(bluePrintRuntimeService, dictionarySource, sourceNodeTemplate)
resourceAssignment.dictionarySource.equals(ResourceDictionaryConstants.SOURCE_INPUT) ||
resourceAssignment.dictionarySource.equals(ResourceDictionaryConstants.SOURCE_DEFAULT)
) &&
- BluePrintTypes.validPrimitiveOrCollectionPrimitive(resourceAssignment.property!!)
+ BlueprintTypes.validPrimitiveOrCollectionPrimitive(resourceAssignment.property!!)
)
}
import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.service.ResourceDefinitionRepoService
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeEnhancerService
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.utils.ResourceDictionaryUtils
interface ResourceDefinitionEnhancerService {
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun enhance(
- bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
- bluePrintRuntimeService: BluePrintRuntimeService<*>
+ bluePrintTypeEnhancerService: BlueprintTypeEnhancerService,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>
): List<ResourceDefinition>
}
// 3. Collect the Resource Definition for Resource Assignment names from database.
// 4. Create the Resource Definition under blueprint base path.
override fun enhance(
- bluePrintTypeEnhancerService: BluePrintTypeEnhancerService,
- bluePrintRuntimeService: BluePrintRuntimeService<*>
+ bluePrintTypeEnhancerService: BlueprintTypeEnhancerService,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>
): List<ResourceDefinition> {
var resourceDefinitions: List<ResourceDefinition> = mutableListOf()
}
// Get all the Mapping files from all node templates.
- private fun getAllResourceMappingFiles(blueprintContext: BluePrintContext): List<String>? {
+ private fun getAllResourceMappingFiles(blueprintContext: BlueprintContext): List<String>? {
return blueprintContext.nodeTemplates()?.mapNotNull { nodeTemplateMap ->
}
// Convert file content to ResourceAssignments asynchronously
- private fun getResourceDefinition(blueprintContext: BluePrintContext, files: List<String>) = runBlocking {
+ private fun getResourceDefinition(blueprintContext: BlueprintContext, files: List<String>) = runBlocking {
val blueprintBasePath = blueprintContext.rootPath
val deferredResourceAssignments = mutableListOf<Deferred<List<ResourceAssignment>>>()
for (file in files) {
}
private fun enrichResourceDefinitionSources(
- bluePrintContext: BluePrintContext,
+ bluePrintContext: BlueprintContext,
resourceDefinitions: List<ResourceDefinition>
) {
val sources = resourceDefinitions
.flatten().distinct()
log.info("Enriching Resource Definition sources Node Template: $sources")
sources.forEach {
- BluePrintEnhancerUtils.populateNodeType(bluePrintContext, resourceDefinitionRepoService, it)
+ BlueprintEnhancerUtils.populateNodeType(bluePrintContext, resourceDefinitionRepoService, it)
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.WorkFlowSpecRequest
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.WorkFlowSpecResponse
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.WorkFlowsResponse
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.load.BluePrintDatabaseLoadService
-import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BluePrintEnhancerUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.load.BlueprintDatabaseLoadService
+import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.BlueprintEnhancerUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.deleteNBDir
import org.onap.ccsdk.cds.controllerblueprints.core.httpProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintEnhancerService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintCompileCache
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintCompileCache
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.onap.ccsdk.cds.controllerblueprints.core.updateErrorMessage
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintFileUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintFileUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
import org.onap.ccsdk.cds.error.catalog.core.ErrorCatalogCodes
*/
@Service
-open class BluePrintModelHandler(
- private val bluePrintDatabaseLoadService: BluePrintDatabaseLoadService,
- private val blueprintsProcessorCatalogService: BluePrintCatalogService,
- private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+open class BlueprintModelHandler(
+ private val bluePrintDatabaseLoadService: BlueprintDatabaseLoadService,
+ private val blueprintsProcessorCatalogService: BlueprintCatalogService,
+ private val bluePrintLoadConfiguration: BlueprintLoadConfiguration,
private val blueprintModelSearchRepository: BlueprintModelSearchRepository,
private val blueprintModelRepository: BlueprintModelRepository,
private val blueprintModelContentRepository: BlueprintModelContentRepository,
- private val bluePrintEnhancerService: BluePrintEnhancerService
+ private val bluePrintEnhancerService: BlueprintEnhancerService
) {
- private val log = logger(BluePrintModelHandler::class)
+ private val log = logger(BlueprintModelHandler::class)
open suspend fun bootstrapBlueprint(bootstrapRequest: BootstrapRequest) {
log.info(
bluePrintDatabaseLoadService.initResourceDictionary()
}
if (bootstrapRequest.loadCBA) {
- bluePrintDatabaseLoadService.initBluePrintCatalog()
+ bluePrintDatabaseLoadService.initBlueprintCatalog()
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open suspend fun prepareWorkFlowSpec(req: WorkFlowSpecRequest):
WorkFlowSpecResponse {
val basePath = blueprintsProcessorCatalogService.getFromDatabase(
)
log.info("blueprint base path $basePath")
- val blueprintContext = BluePrintMetadataUtils.getBluePrintContext(basePath.toString())
+ val blueprintContext = BlueprintMetadataUtils.getBlueprintContext(basePath.toString())
val workFlow = blueprintContext.workflowByName(req.workflowName)
val wfRes = WorkFlowSpecResponse()
return wfRes
}
- private fun addPropertyInfo(propName: String, prop: PropertyDefinition, ctx: BluePrintContext, res: WorkFlowSpecResponse) {
+ private fun addPropertyInfo(propName: String, prop: PropertyDefinition, ctx: BlueprintContext, res: WorkFlowSpecResponse) {
updatePropertyInfo(propName, prop, ctx, res)
addDataType(prop.type, ctx, res)
if (prop.entrySchema != null && prop.entrySchema!!.type != null) {
}
}
- private fun updatePropertyInfo(name: String, prop: PropertyDefinition, ctx: BluePrintContext, res: WorkFlowSpecResponse) {
+ private fun updatePropertyInfo(name: String, prop: PropertyDefinition, ctx: BlueprintContext, res: WorkFlowSpecResponse) {
if (prop.inputparam == null || prop.inputparam == false) {
var workflow = ctx.workflowByName(res.workFlowData.workFlowName)
for ((k, v) in workflow.steps!!) {
}
}
- private fun addDataType(name: String, ctx: BluePrintContext, res: WorkFlowSpecResponse) {
+ private fun addDataType(name: String, ctx: BlueprintContext, res: WorkFlowSpecResponse) {
var data = ctx.dataTypeByName(name)
if (data != null) {
res.dataTypes?.put(name, data)
}
}
- private fun addParentDataType(data: DataType, ctx: BluePrintContext, res: WorkFlowSpecResponse) {
+ private fun addParentDataType(data: DataType, ctx: BlueprintContext, res: WorkFlowSpecResponse) {
if (data.properties != null) {
for ((k, v) in data.properties!!) {
addPropertyInfo(k, v, ctx, res)
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open suspend fun getWorkflowNames(name: String, version: String): WorkFlowsResponse {
val basePath = blueprintsProcessorCatalogService.getFromDatabase(
name, version
res.blueprintName = name
res.version = version
- val blueprintContext = BluePrintMetadataUtils.getBluePrintContext(
+ val blueprintContext = BlueprintMetadataUtils.getBlueprintContext(
basePath.toString()
)
if (blueprintContext.workflows() != null) {
*
* @param filePart filePart
* @return Mono<BlueprintModelSearch>
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
</BlueprintModelSearch> */
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open suspend fun saveBlueprintModel(filePart: FilePart): BlueprintModelSearch {
try {
return upload(filePart, false)
* @param name name
* @param version version
* @return BlueprintModelSearch
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun getBlueprintModelSearchByNameAndVersion(name: String, version: String): BlueprintModelSearch? {
return blueprintModelSearchRepository.findByArtifactNameAndArtifactVersion(name, version)
- /*?: throw BluePrintException(
+ /*?: throw BlueprintException(
ErrorCode.RESOURCE_NOT_FOUND.value,
String.format(BLUEPRINT_MODEL_NAME_VERSION_FAILURE_MSG, name, version)
)*/
* @param name name
* @param version version
* @return ResponseEntity<Resource>
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
</Resource> */
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun downloadBlueprintModelFileByNameAndVersion(
name: String,
version: String
val archiveByteArray = download(name, version)
val fileName = "${name}_$version.zip"
return prepareResourceEntity(fileName, archiveByteArray)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
e.http(ErrorCatalogCodes.RESOURCE_NOT_FOUND)
val errorMsg = "Error while downloading the CBA file by Blueprint Name ($name) and Version ($version)."
throw e.updateErrorMessage(
* This is a downloadBlueprintModelFile method to find the target file to download and return a file resource
*
* @return ResponseEntity<Resource>
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
</Resource> */
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun downloadBlueprintModelFile(id: String): ResponseEntity<Resource> {
val blueprintModel: BlueprintModel
try {
blueprintModel = getBlueprintModel(id)
- } catch (e: BluePrintException) {
+ } catch (e: BlueprintException) {
throw httpProcessorException(
ErrorCatalogCodes.RESOURCE_NOT_FOUND, DesignerApiDomains.DESIGNER_API,
"Error while downloading the CBA file: couldn't get blueprint modelby ID ($id)",
*
* @param id id
* @return BlueprintModel
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun getBlueprintModel(id: String): BlueprintModel {
val blueprintModel: BlueprintModel
val dbBlueprintModel = blueprintModelRepository.findById(id)
* @param name name
* @param version version
* @return BlueprintModel
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun getBlueprintModelByNameAndVersion(name: String, version: String): BlueprintModel {
val blueprintModel = blueprintModelRepository
.findByArtifactNameAndArtifactVersion(name, version)
*
* @param id id
* @return BlueprintModelSearch
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun getBlueprintModelSearch(id: String): BlueprintModelSearch {
return blueprintModelSearchRepository.findById(id)
?: throw httpProcessorException(
}
/**
- * This is a searchBluePrintModelsByKeyWord method to retrieve specific BlueprintModel in Database
+ * This is a searchBlueprintModelsByKeyWord method to retrieve specific BlueprintModel in Database
* where keyword equals updatedBy or tags or artifcat name or artifcat version or artifact type
* @author Shaaban Ebrahim
* @param keyWord
*
* @return List<BlueprintModelSearch> list of the controller blueprint
</BlueprintModelSearch> */
- open fun searchBluePrintModelsByKeyWord(keyWord: String): List<BlueprintModelSearch> {
+ open fun searchBlueprintModelsByKeyWord(keyWord: String): List<BlueprintModelSearch> {
return blueprintModelSearchRepository.findByUpdatedByOrTagsOrOrArtifactNameOrOrArtifactVersionOrArtifactType(
keyWord, keyWord, keyWord, keyWord, keyWord
)
}
/**
- * This is a searchBluePrintModelsByKeyWordPagebale method to retrieve specific BlueprintModel in Database
+ * This is a searchBlueprintModelsByKeyWordPagebale method to retrieve specific BlueprintModel in Database
* where keyword equals updatedBy or tags or artifcat name or artifcat version or artifact type and pageable
* @author Shaaban Ebrahim
* @param keyWord
*
* @return List<BlueprintModelSearch> list of the controller blueprint
</BlueprintModelSearch> */
- open fun searchBluePrintModelsByKeyWordPaged(keyWord: String, pageRequest: PageRequest): Page<BlueprintModelSearch> {
+ open fun searchBlueprintModelsByKeyWordPaged(keyWord: String, pageRequest: PageRequest): Page<BlueprintModelSearch> {
return blueprintModelSearchRepository.findByUpdatedByContainingIgnoreCaseOrTagsContainingIgnoreCaseOrArtifactNameContainingIgnoreCaseOrArtifactVersionContainingIgnoreCaseOrArtifactTypeContainingIgnoreCase(
keyWord,
keyWord,
* This is a deleteBlueprintModel method
*
* @param id id
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
@Transactional
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open fun deleteBlueprintModel(id: String) {
val dbBlueprintModel = blueprintModelRepository.findById(id)
if (dbBlueprintModel.isPresent) {
*
* @param filePart filePart
* @return ResponseEntity<Resource>
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open suspend fun enrichBlueprint(filePart: FilePart): ResponseEntity<Resource> {
try {
val enhancedByteArray = enrichBlueprintFileSource(filePart)
- return BluePrintEnhancerUtils.prepareResourceEntity("enhanced-cba.zip", enhancedByteArray)
- } catch (e: BluePrintProcessorException) {
+ return BlueprintEnhancerUtils.prepareResourceEntity("enhanced-cba.zip", enhancedByteArray)
+ } catch (e: BlueprintProcessorException) {
e.http(ErrorCatalogCodes.IO_FILE_INTERRUPT)
val errorMsg = "Error while enhancing the CBA package."
throw e.updateErrorMessage(
*
* @param filePart filePart
* @return BlueprintModelSearch
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open suspend fun publishBlueprint(filePart: FilePart): BlueprintModelSearch {
try {
return upload(filePart, true)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
e.http(ErrorCatalogCodes.IO_FILE_INTERRUPT)
val errorMsg = "Error in Publishing CBA."
throw e.updateErrorMessage(
*
* @param filePart filePart
* @return BlueprintModelSearch
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open suspend fun enrichAndPublishBlueprint(filePart: FilePart): BlueprintModelSearch {
try {
val enhancedByteArray = enrichBlueprintFileSource(filePart)
return upload(enhancedByteArray, true)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
e.http(ErrorCatalogCodes.IO_FILE_INTERRUPT)
val errorMsg = "Error while enhancing and uploading the CBA package."
throw e.updateErrorMessage(
try {
val compressedFile = normalizedFile(blueprintArchive, "cba.zip")
when (fileSource) {
- is FilePart -> BluePrintEnhancerUtils.filePartAsFile(fileSource, compressedFile)
- is ByteArray -> BluePrintEnhancerUtils.byteArrayAsFile(fileSource, compressedFile)
+ is FilePart -> BlueprintEnhancerUtils.filePartAsFile(fileSource, compressedFile)
+ is ByteArray -> BlueprintEnhancerUtils.byteArrayAsFile(fileSource, compressedFile)
}
// Save the Copied file to Database
val blueprintId = blueprintsProcessorCatalogService.saveToDatabase(saveId, compressedFile, validate)
ErrorCatalogCodes.RESOURCE_NOT_FOUND, DesignerApiDomains.DESIGNER_API,
String.format(BLUEPRINT_MODEL_ID_FAILURE_MSG, blueprintId)
)
- } catch (e: BluePrintException) {
+ } catch (e: BlueprintException) {
e.http(ErrorCatalogCodes.IO_FILE_INTERRUPT)
val errorMsg = "Error in Upload CBA."
throw e.updateErrorMessage(
)
} finally {
// Clean blueprint script cache
- val cacheKey = BluePrintFileUtils
+ val cacheKey = BlueprintFileUtils
.compileCacheKey(normalizedPathName(bluePrintLoadConfiguration.blueprintWorkingPath, saveId))
- BluePrintCompileCache.cleanClassLoader(cacheKey)
+ BlueprintCompileCache.cleanClassLoader(cacheKey)
deleteNBDir(blueprintArchive)
deleteNBDir(blueprintWorking)
}
ErrorCatalogCodes.RESOURCE_NOT_FOUND, DesignerApiDomains.DESIGNER_API,
"Error while downloading the CBA file: couldn't get model content"
)
- } catch (e: BluePrintException) {
+ } catch (e: BlueprintException) {
e.http(ErrorCatalogCodes.RESOURCE_NOT_FOUND)
val errorMsg = "Fail to get Blueprint Model content."
throw e.updateErrorMessage(
try {
when (fileSource) {
is FilePart ->
- BluePrintEnhancerUtils
+ BlueprintEnhancerUtils
.copyFilePartToEnhanceDir(fileSource, blueprintArchive, blueprintWorkingDir)
is ByteArray ->
- BluePrintEnhancerUtils
+ BlueprintEnhancerUtils
.copyByteArrayToEnhanceDir(fileSource, blueprintArchive, blueprintWorkingDir)
} // Enhance the Blue Prints
bluePrintEnhancerService.enhance(blueprintWorkingDir)
- return BluePrintEnhancerUtils.compressEnhanceDirAndReturnByteArray(blueprintWorkingDir, blueprintArchive)
- } catch (e: BluePrintException) {
+ return BlueprintEnhancerUtils.compressEnhanceDirAndReturnByteArray(blueprintWorkingDir, blueprintArchive)
+ } catch (e: BlueprintException) {
e.http(ErrorCatalogCodes.IO_FILE_INTERRUPT)
val errorMsg = "Fail Enriching the CBA."
throw e.updateErrorMessage(DesignerApiDomains.DESIGNER_API, errorMsg)
"Error while Enriching the CBA file.", e.errorCauseOrDefault()
)
} finally {
- BluePrintEnhancerUtils.cleanEnhancer(blueprintArchive, blueprintWorkingDir)
+ BlueprintEnhancerUtils.cleanEnhancer(blueprintArchive, blueprintWorkingDir)
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ModelType
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.repository.ModelTypeRepository
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils.ModelTypeValidator
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.httpProcessorException
import org.onap.ccsdk.cds.error.catalog.core.ErrorCatalogCodes
import org.slf4j.LoggerFactory
*
* @param modelType modelType
* @return ModelType
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
open suspend fun saveModel(modelType: ModelType): ModelType {
lateinit var dbModel: ModelType
ModelTypeValidator.validateModelType(modelType)
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.DesignerApiDomains
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ResourceDictionary
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.repository.ResourceDictionaryRepository
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.httpProcessorException
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
*
* @param name name
* @return DataDictionary
- * @throws BluePrintException BluePrintException
+ * @throws BlueprintException BlueprintException
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun getResourceDictionaryByName(name: String): ResourceDictionary {
Preconditions.checkArgument(StringUtils.isNotBlank(name), "Resource dictionary Name Information is missing.")
val resourceDictionaryDb = resourceDictionaryRepository.findByName(name)
* @param resourceDictionary resourceDictionary
* @return DataDictionary
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun saveResourceDictionary(resourceDictionary: ResourceDictionary): ResourceDictionary {
var resourceDictionary = resourceDictionary
* @param resourceDefinition ResourceDefinition
* @return ResourceDefinition
*/
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
suspend fun saveResourceDefinition(resourceDefinition: ResourceDefinition): ResourceDefinition {
val resourceDictionary = ResourceDictionary()
resourceDictionary.name = resourceDefinition.name
import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
import org.apache.commons.lang.text.StrBuilder
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import java.io.File
import java.util.UUID
@Service
-open class BluePrintCatalogLoadService(private val controllerBlueprintsCatalogService: BluePrintCatalogService) {
+open class BlueprintCatalogLoadService(private val controllerBlueprintsCatalogService: BlueprintCatalogService) {
- private val log = LoggerFactory.getLogger(BluePrintCatalogLoadService::class.java)
+ private val log = LoggerFactory.getLogger(BlueprintCatalogLoadService::class.java)
- open fun loadPathsBluePrintModelCatalog(paths: List<String>) {
- paths.forEach { loadPathBluePrintModelCatalog(it) }
+ open fun loadPathsBlueprintModelCatalog(paths: List<String>) {
+ paths.forEach { loadPathBlueprintModelCatalog(it) }
}
- open fun loadPathBluePrintModelCatalog(path: String) {
+ open fun loadPathBlueprintModelCatalog(path: String) {
val files = File(path).listFiles()
runBlocking {
for (file in files) {
deferredResults += async {
- loadBluePrintModelCatalog(errorBuilder, file)
+ loadBlueprintModelCatalog(errorBuilder, file)
}
}
}
}
- open suspend fun loadBluePrintModelCatalog(errorBuilder: StrBuilder, file: File) {
+ open suspend fun loadBlueprintModelCatalog(errorBuilder: StrBuilder, file: File) {
try {
controllerBlueprintsCatalogService.saveToDatabase(UUID.randomUUID().toString(), file)
} catch (e: Exception) {
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.load
import kotlinx.coroutines.runBlocking
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
@Service
-open class BluePrintDatabaseLoadService(
- private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
+open class BlueprintDatabaseLoadService(
+ private val bluePrintLoadConfiguration: BlueprintLoadConfiguration,
private val modelTypeLoadService: ModelTypeLoadService,
private val resourceDictionaryLoadService: ResourceDictionaryLoadService,
- private val bluePrintCatalogLoadService: BluePrintCatalogLoadService
+ private val bluePrintCatalogLoadService: BlueprintCatalogLoadService
) {
- private val log = LoggerFactory.getLogger(BluePrintDatabaseLoadService::class.java)
+ private val log = LoggerFactory.getLogger(BlueprintDatabaseLoadService::class.java)
open fun init() = runBlocking {
initModelTypes()
initResourceDictionary()
- initBluePrintCatalog()
+ initBlueprintCatalog()
}
open suspend fun initModelTypes() {
}
}
- open suspend fun initBluePrintCatalog() {
- log.info("cba load from paths(${bluePrintLoadConfiguration.loadBluePrintPaths})")
+ open suspend fun initBlueprintCatalog() {
+ log.info("cba load from paths(${bluePrintLoadConfiguration.loadBlueprintPaths})")
- val paths = bluePrintLoadConfiguration.loadBluePrintPaths?.split(",")
+ val paths = bluePrintLoadConfiguration.loadBlueprintPaths?.split(",")
paths?.let {
- bluePrintCatalogLoadService.loadPathsBluePrintModelCatalog(paths)
+ bluePrintCatalogLoadService.loadPathsBlueprintModelCatalog(paths)
}
}
}
import org.apache.commons.lang3.text.StrBuilder
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ModelType
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.ModelTypeHandler
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.EntityType
val definitionType: String?
when (T::class) {
DataType::class -> {
- definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ definitionType = BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
}
RelationshipType::class -> {
- definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE
+ definitionType = BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE
}
ArtifactType::class -> {
- definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE
+ definitionType = BlueprintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE
}
NodeType::class -> {
- definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE
+ definitionType = BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE
}
else -> {
- throw BluePrintException("couldn't process model type($classType) definition")
+ throw BlueprintException("couldn't process model type($classType) definition")
}
}
modelType.definitionType = definitionType
import kotlinx.coroutines.coroutineScope
import org.apache.commons.lang3.text.StrBuilder
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.ResourceDictionaryHandler
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.readNBText
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
resourceDictionaryHandler.saveResourceDefinition(resourceDefinition)
log.trace("Resource dictionary(${file.name}) loaded successfully ")
} else {
- throw BluePrintException("couldn't get dictionary from content information")
+ throw BlueprintException("couldn't get dictionary from content information")
}
} catch (e: Exception) {
errorBuilder.appendln("Couldn't load Resource dictionary (${file.name}: ${e.message})")
import org.apache.commons.lang3.StringUtils
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.repository.ModelTypeRepository
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.repository.ResourceDictionaryRepository
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import org.springframework.stereotype.Service
-interface ResourceDefinitionRepoService : BluePrintRepoService {
+interface ResourceDefinitionRepoService : BlueprintRepoService {
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
fun getResourceDefinition(resourceDefinitionName: String): ResourceDefinition
}
@Service
-open class BluePrintRepoFileService(
+open class BlueprintRepoFileService(
private val modelTypeRepository: ModelTypeRepository,
private val resourceDictionaryRepository: ResourceDictionaryRepository
) : ResourceDefinitionRepoService {
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
override fun getNodeType(nodeTypeName: String): NodeType {
return getModelType(nodeTypeName, NodeType::class.java)
- ?: throw BluePrintException("couldn't get NodeType($nodeTypeName)")
+ ?: throw BlueprintException("couldn't get NodeType($nodeTypeName)")
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
override fun getDataType(dataTypeName: String): DataType {
return getModelType(dataTypeName, DataType::class.java)
- ?: throw BluePrintException("couldn't get DataType($dataTypeName)")
+ ?: throw BlueprintException("couldn't get DataType($dataTypeName)")
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
override fun getArtifactType(artifactTypeName: String): ArtifactType {
return getModelType(artifactTypeName, ArtifactType::class.java)
- ?: throw BluePrintException("couldn't get ArtifactType($artifactTypeName)")
+ ?: throw BlueprintException("couldn't get ArtifactType($artifactTypeName)")
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
override fun getRelationshipType(relationshipTypeName: String): RelationshipType {
return getModelType(relationshipTypeName, RelationshipType::class.java)
- ?: throw BluePrintException("couldn't get RelationshipType($relationshipTypeName)")
+ ?: throw BlueprintException("couldn't get RelationshipType($relationshipTypeName)")
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
override fun getCapabilityDefinition(capabilityDefinitionName: String): CapabilityDefinition {
return getModelType(capabilityDefinitionName, CapabilityDefinition::class.java)
- ?: throw BluePrintException("couldn't get CapabilityDefinition($capabilityDefinitionName)")
+ ?: throw BlueprintException("couldn't get CapabilityDefinition($capabilityDefinitionName)")
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
override fun getResourceDefinition(resourceDefinitionName: String): ResourceDefinition {
val dbResourceDictionary = resourceDictionaryRepository.findByName(resourceDefinitionName)
return if (dbResourceDictionary != null) {
dbResourceDictionary.definition
} else {
- throw BluePrintException(String.format("failed to get resource dictionary (%s) from repo", resourceDefinitionName))
+ throw BlueprintException(String.format("failed to get resource dictionary (%s) from repo", resourceDefinitionName))
}
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
private fun <T> getModelType(modelName: String, valueClass: Class<T>): T? {
Preconditions.checkArgument(
StringUtils.isNotBlank(modelName),
return JacksonUtils.readValue(modelDefinition, valueClass)
}
- @Throws(BluePrintException::class)
+ @Throws(BlueprintException::class)
private fun getModelDefinition(modelName: String): JsonNode {
val modelDefinition: JsonNode
val modelTypeDb = modelTypeRepository.findByModelName(modelName)
if (modelTypeDb != null) {
modelDefinition = modelTypeDb.definition
} else {
- throw BluePrintException(String.format("failed to get model definition (%s) from repo", modelName))
+ throw BlueprintException(String.format("failed to get model definition (%s) from repo", modelName))
}
return modelDefinition
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api.utils
import kotlinx.coroutines.reactive.awaitSingle
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
import org.onap.ccsdk.cds.controllerblueprints.core.data.RelationshipType
import org.onap.ccsdk.cds.controllerblueprints.core.deCompress
import org.onap.ccsdk.cds.controllerblueprints.core.deleteNBDir
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintRepoService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintRepoService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
import org.onap.ccsdk.cds.controllerblueprints.core.reCreateNBDirs
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintArchiveUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils
import org.springframework.core.io.ByteArrayResource
import org.springframework.core.io.Resource
import org.springframework.http.HttpHeaders
import java.io.File
import java.nio.file.Paths
-class BluePrintEnhancerUtils {
+class BlueprintEnhancerUtils {
companion object {
- val log = logger(BluePrintEnhancerUtils)
+ val log = logger(BlueprintEnhancerUtils)
fun populateDataTypes(
- bluePrintContext: BluePrintContext,
- bluePrintRepoService: BluePrintRepoService,
+ bluePrintContext: BlueprintContext,
+ bluePrintRepoService: BlueprintRepoService,
dataTypeName: String
): DataType {
val dataType = bluePrintContext.serviceTemplate.dataTypes?.get(dataTypeName)
?: bluePrintRepoService.getDataType(dataTypeName)
- ?: throw BluePrintException("couldn't get DataType($dataTypeName) from repo.")
+ ?: throw BlueprintException("couldn't get DataType($dataTypeName) from repo.")
bluePrintContext.serviceTemplate.dataTypes?.put(dataTypeName, dataType)
return dataType
}
fun populateRelationshipType(
- bluePrintContext: BluePrintContext,
- bluePrintRepoService: BluePrintRepoService,
+ bluePrintContext: BlueprintContext,
+ bluePrintRepoService: BlueprintRepoService,
relationshipName: String
): RelationshipType {
val relationshipType = bluePrintContext.serviceTemplate.relationshipTypes?.get(relationshipName)
?: bluePrintRepoService.getRelationshipType(relationshipName)
- ?: throw BluePrintException("couldn't get RelationshipType($relationshipName) from repo.")
+ ?: throw BlueprintException("couldn't get RelationshipType($relationshipName) from repo.")
bluePrintContext.serviceTemplate.relationshipTypes?.put(relationshipName, relationshipType)
return relationshipType
}
fun populateNodeType(
- bluePrintContext: BluePrintContext,
- bluePrintRepoService: BluePrintRepoService,
+ bluePrintContext: BlueprintContext,
+ bluePrintRepoService: BlueprintRepoService,
nodeTypeName: String
): NodeType {
val nodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(nodeTypeName)
?: bluePrintRepoService.getNodeType(nodeTypeName)
- ?: throw BluePrintException("couldn't get NodeType($nodeTypeName) from repo.")
+ ?: throw BlueprintException("couldn't get NodeType($nodeTypeName) from repo.")
bluePrintContext.serviceTemplate.nodeTypes?.put(nodeTypeName, nodeType)
return nodeType
}
fun populateArtifactType(
- bluePrintContext: BluePrintContext,
- bluePrintRepoService: BluePrintRepoService,
+ bluePrintContext: BlueprintContext,
+ bluePrintRepoService: BlueprintRepoService,
artifactTypeName: String
): ArtifactType {
val artifactType = bluePrintContext.serviceTemplate.artifactTypes?.get(artifactTypeName)
?: bluePrintRepoService.getArtifactType(artifactTypeName)
- ?: throw BluePrintException("couldn't get ArtifactType($artifactTypeName) from repo.")
+ ?: throw BlueprintException("couldn't get ArtifactType($artifactTypeName) from repo.")
bluePrintContext.serviceTemplate.artifactTypes?.put(artifactTypeName, artifactType)
return artifactType
}
outputFileName: String = "enhanced-cba.zip"
): ByteArray {
val compressedFile = normalizedFile(archiveDir, outputFileName)
- BluePrintArchiveUtils.compress(Paths.get(enhanceDir).toFile(), compressedFile)
+ BlueprintArchiveUtils.compress(Paths.get(enhanceDir).toFile(), compressedFile)
return compressedFile.readBytes()
}
):
ResponseEntity<Resource> {
val compressedFile = normalizedFile(archiveDir, outputFileName)
- BluePrintArchiveUtils.compress(Paths.get(enhanceDir).toFile(), compressedFile)
+ BlueprintArchiveUtils.compress(Paths.get(enhanceDir).toFile(), compressedFile)
return prepareResourceEntity(compressedFile)
}
import com.fasterxml.jackson.databind.JsonNode
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ModelType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactType
import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
fun validateModelTypeDefinition(definitionType: String, definitionContent: JsonNode): Boolean {
when (definitionType) {
- BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE -> {
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE -> {
JacksonUtils.readValue(definitionContent, DataType::class.java)
- ?: throw BluePrintException("Model type definition is not DataType valid content $definitionContent")
+ ?: throw BlueprintException("Model type definition is not DataType valid content $definitionContent")
}
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE -> {
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE -> {
JacksonUtils.readValue(definitionContent, NodeType::class.java)
- ?: throw BluePrintException("Model type definition is not NodeType valid content $definitionContent")
+ ?: throw BlueprintException("Model type definition is not NodeType valid content $definitionContent")
}
- BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE -> {
+ BlueprintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE -> {
JacksonUtils.readValue(definitionContent, ArtifactType::class.java)
- ?: throw BluePrintException("Model type definition is not ArtifactType valid content $definitionContent")
+ ?: throw BlueprintException("Model type definition is not ArtifactType valid content $definitionContent")
}
- BluePrintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE -> {
+ BlueprintConstants.MODEL_DEFINITION_TYPE_CAPABILITY_TYPE -> {
JacksonUtils.readValue(definitionContent, CapabilityDefinition::class.java)
- ?: throw BluePrintException("Model type definition is not CapabilityDefinition valid content $definitionContent")
+ ?: throw BlueprintException("Model type definition is not CapabilityDefinition valid content $definitionContent")
}
- BluePrintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE -> {
+ BlueprintConstants.MODEL_DEFINITION_TYPE_RELATIONSHIP_TYPE -> {
JacksonUtils.readValue(definitionContent, RelationshipType::class.java)
- ?: throw BluePrintException("Model type definition is not RelationshipType valid content $definitionContent")
+ ?: throw BlueprintException("Model type definition is not RelationshipType valid content $definitionContent")
}
}
return true
fun validateModelType(modelType: ModelType?): Boolean {
checkNotNull(modelType) { "Model Type Information is missing." }
- val validRootTypes = BluePrintTypes.validModelTypes()
+ val validRootTypes = BlueprintTypes.validModelTypes()
check(validRootTypes.contains(modelType.definitionType)) {
"Not Valid Model Root Type(${modelType.definitionType}), It should be $validRootTypes"
import org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.compress
import org.onap.ccsdk.cds.controllerblueprints.core.deleteDir
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementServiceGrpc
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput
import org.onap.ccsdk.cds.controllerblueprints.management.api.DownloadAction
import org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk
import org.onap.ccsdk.cds.controllerblueprints.management.api.RemoveAction
classes = [DesignerApiTestConfiguration::class, ErrorCatalogTestConfiguration::class]
)
@TestPropertySource(locations = ["classpath:application-test.properties"])
-class BluePrintManagementGRPCHandlerTest {
+class BlueprintManagementGRPCHandlerTest {
@get:Rule
val grpcServerRule = GrpcServerRule().directExecutor()
@Autowired
- lateinit var bluePrintManagementGRPCHandler: BluePrintManagementGRPCHandler
+ lateinit var bluePrintManagementGRPCHandler: BlueprintManagementGRPCHandler
@BeforeTest
fun init() {
@Test
fun testBootstrap() {
- val blockingStub = BluePrintManagementServiceGrpc.newBlockingStub(grpcServerRule.channel)
+ val blockingStub = BlueprintManagementServiceGrpc.newBlockingStub(grpcServerRule.channel)
val id = "123_Bootstrap"
val req = createBootstrapInputRequest(id)
val bootstrapOutput = blockingStub.bootstrapBlueprint(req)
assertEquals(200, bootstrapOutput.status.code)
assertTrue(
- bootstrapOutput.status.message!!.contentEquals(BluePrintConstants.STATUS_SUCCESS),
+ bootstrapOutput.status.message!!.contentEquals(BlueprintConstants.STATUS_SUCCESS),
"failed to get success status"
)
assertEquals(EventType.EVENT_COMPONENT_EXECUTED, bootstrapOutput.status.eventType)
@Test
fun `test upload and download blueprint`() {
- val blockingStub = BluePrintManagementServiceGrpc.newBlockingStub(grpcServerRule.channel)
+ val blockingStub = BlueprintManagementServiceGrpc.newBlockingStub(grpcServerRule.channel)
val id = "123_upload"
val req = createUploadInputRequest(id, UploadAction.PUBLISH.toString())
val output = blockingStub.uploadBlueprint(req)
assertEquals(200, output.status.code)
assertTrue(
- output.status.message!!.contentEquals(BluePrintConstants.STATUS_SUCCESS),
+ output.status.message!!.contentEquals(BlueprintConstants.STATUS_SUCCESS),
"failed to get success status"
)
assertEquals(EventType.EVENT_COMPONENT_EXECUTED, output.status.eventType)
val downloadOutput = blockingStub.downloadBlueprint(downloadReq)
assertEquals(200, downloadOutput.status.code)
assertTrue(
- downloadOutput.status.message!!.contentEquals(BluePrintConstants.STATUS_SUCCESS),
+ downloadOutput.status.message!!.contentEquals(BlueprintConstants.STATUS_SUCCESS),
"failed to get success status"
)
assertEquals(EventType.EVENT_COMPONENT_EXECUTED, downloadOutput.status.eventType)
@Test
fun `test delete blueprint`() {
- val blockingStub = BluePrintManagementServiceGrpc.newBlockingStub(grpcServerRule.channel)
+ val blockingStub = BlueprintManagementServiceGrpc.newBlockingStub(grpcServerRule.channel)
val id = "123_delete"
val req = createUploadInputRequest(id, UploadAction.DRAFT.toString())
var output = blockingStub.uploadBlueprint(req)
assertEquals(200, output.status.code)
assertTrue(
- output.status.message!!.contentEquals(BluePrintConstants.STATUS_SUCCESS),
+ output.status.message!!.contentEquals(BlueprintConstants.STATUS_SUCCESS),
"failed to get success status"
)
assertEquals(id, output.commonHeader.requestId)
val basicAuthGrpcClientService = TokenAuthGrpcClientService(tokenAuthGrpcClientProperties)
val channel = basicAuthGrpcClientService.channel()
- val blockingStub = BluePrintManagementServiceGrpc.newBlockingStub(channel)
+ val blockingStub = BlueprintManagementServiceGrpc.newBlockingStub(channel)
val bluePrintUploadInput = createUploadInputRequest("12345", UploadAction.DRAFT.toString())
}
}
- private fun createBootstrapInputRequest(id: String): BluePrintBootstrapInput {
+ private fun createBootstrapInputRequest(id: String): BlueprintBootstrapInput {
val commonHeader = CommonHeader
.newBuilder()
.setTimestamp("2012-04-23T18:25:43.511Z")
.setRequestId(id)
.setSubRequestId("1234-56").build()
- return BluePrintBootstrapInput.newBuilder()
+ return BlueprintBootstrapInput.newBuilder()
.setCommonHeader(commonHeader)
.setLoadModelType(false)
.setLoadResourceDictionary(false)
.build()
}
- private fun createUploadInputRequest(id: String, action: String): BluePrintUploadInput {
+ private fun createUploadInputRequest(id: String, action: String): BlueprintUploadInput {
val file = normalizedFile("./target/blueprints/generated-cba.zip")
assertTrue(file.exists(), "couldnt get file ${file.absolutePath}")
val fileChunk = FileChunk.newBuilder().setChunk(ByteString.copyFrom(file.inputStream().readBytes()))
.build()
- return BluePrintUploadInput.newBuilder()
+ return BlueprintUploadInput.newBuilder()
.setCommonHeader(commonHeader)
.setActionIdentifiers(actionIdentifier)
.setFileChunk(fileChunk)
.build()
}
- private fun createDownloadInputRequest(id: String, action: String): BluePrintDownloadInput {
+ private fun createDownloadInputRequest(id: String, action: String): BlueprintDownloadInput {
val commonHeader = CommonHeader
.newBuilder()
.setTimestamp("2012-04-23T18:25:43.511Z")
.setRequestId(id)
.setSubRequestId("1234-56").build()
- return BluePrintDownloadInput.newBuilder()
+ return BlueprintDownloadInput.newBuilder()
.setCommonHeader(commonHeader)
.setActionIdentifiers(
ActionIdentifiers.newBuilder()
.build()
}
- private fun createRemoveInputRequest(id: String): BluePrintRemoveInput {
+ private fun createRemoveInputRequest(id: String): BlueprintRemoveInput {
val commonHeader = CommonHeader
.newBuilder()
.setTimestamp("2012-04-23T18:25:43.511Z")
.setRequestId(id)
.setSubRequestId("1234-56").build()
- return BluePrintRemoveInput.newBuilder()
+ return BlueprintRemoveInput.newBuilder()
.setCommonHeader(commonHeader)
.setActionIdentifiers(
ActionIdentifiers.newBuilder()
import org.junit.runners.MethodSorters
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.domain.BlueprintModelSearch
import org.onap.ccsdk.cds.controllerblueprints.core.compress
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
import org.onap.ccsdk.cds.controllerblueprints.core.deleteDir
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
@Autowired
lateinit var webTestClient: WebTestClient
- private var bluePrintLoadConfiguration: BluePrintLoadConfiguration? = null
+ private var bluePrintLoadConfiguration: BlueprintLoadConfiguration? = null
private val blueprintDir = "./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
private var zipBlueprintFileName: String? = null
fun setUp() {
assertNotNull(webTestClient, " Failed to create WebTestClient")
- bluePrintLoadConfiguration = BluePrintLoadConfiguration().apply {
+ bluePrintLoadConfiguration = BlueprintLoadConfiguration().apply {
blueprintArchivePath = "./target/blueprints/archive"
blueprintWorkingPath = "./target/blueprints/work"
blueprintDeployPath = "./target/blueprints/deploy"
}
@Test
- fun test01_saveBluePrint() {
+ fun test01_saveBlueprint() {
bp = runBlocking {
val body = MultipartBodyBuilder().apply {
part(
@Test
@Throws(JSONException::class)
- fun test02_getBluePrintByNameAndVersion() {
+ fun test02_getBlueprintByNameAndVersion() {
webTestClient(
HttpMethod.GET, null,
"/api/v1/blueprint-model/by-name/${bp!!.artifactName}/version/${bp!!.artifactVersion}",
@Test
@Throws(JSONException::class)
- fun test05_downloadBluePrint() {
+ fun test05_downloadBlueprint() {
webTestClient(
HttpMethod.GET, null,
"/api/v1/blueprint-model/download/${bp!!.id}",
}
@Test
- fun test10_deleteBluePrint() {
+ fun test10_deleteBlueprint() {
// webTestClient.delete().uri("/api/v1/blueprint-model/${bp!!.id}")
// .header("Authorization", "Basic " + Base64Utils
// .encodeToString(("ccsdkapps" + ":" + "ccsdkapps").toByteArray(UTF_8)))
import org.junit.runner.RunWith
import org.junit.runners.MethodSorters
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ModelType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
val content = JacksonUtils.getClassPathFileContent("model_type/data_type/datatype-property.json")
var modelType = ModelType()
- modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
- modelType.derivedFrom = BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT
+ modelType.definitionType = BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ modelType.derivedFrom = BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT
modelType.description = "Definition for Sample Datatype "
modelType.definition = JacksonUtils.jsonNode(content)
modelType.modelName = modelName
modelType.version = "1.0.0"
modelType.tags = (
- "test-datatype ," + BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT + "," +
- BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ "test-datatype ," + BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT + "," +
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
)
modelType.updatedBy = "xxxxxx@xxx.com"
modelType = modelTypeController.saveModelType(modelType)
Assert.assertNotNull("Failed to get Id for api call getModelByName ", dbModelType!!.modelName)
val dbDatatypeModelTypes =
- modelTypeController.getModelTypeByDefinitionType(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
+ modelTypeController.getModelTypeByDefinitionType(BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
Assert.assertNotNull("Failed to find getModelTypeByDefinitionType by tags", dbDatatypeModelTypes)
Assert.assertTrue("Failed to find getModelTypeByDefinitionType by count", dbDatatypeModelTypes.isNotEmpty())
}
package org.onap.ccsdk.cds.blueprintsprocessor.designer.api
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.PrimaryDatabaseConfiguration
import org.springframework.context.annotation.Bean
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = [
"org.onap.ccsdk.cds.blueprintsprocessor.db.primary",
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.load.ModelTypeLoadService
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.load.ResourceDictionaryLoadService
import org.onap.ccsdk.cds.controllerblueprints.core.deleteDir
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintEnhancerService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintEnhancerService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintValidatorService
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
classes = [DesignerApiTestConfiguration::class]
)
@TestPropertySource(locations = ["classpath:application-test.properties"])
-class BluePrintEnhancerServiceImplTest {
+class BlueprintEnhancerServiceImplTest {
@Autowired
lateinit var modelTypeLoadService: ModelTypeLoadService
lateinit var resourceDictionaryLoadService: ResourceDictionaryLoadService
@Autowired
- lateinit var bluePrintEnhancerService: BluePrintEnhancerService
+ lateinit var bluePrintEnhancerService: BlueprintEnhancerService
@Autowired
- lateinit var bluePrintValidatorService: BluePrintValidatorService
+ lateinit var bluePrintValidatorService: BlueprintValidatorService
@Test
@Throws(Exception::class)
val bluePrintContext = bluePrintEnhancerService.enhance(basePath, targetPath)
Assert.assertNotNull("failed to get blueprintContext ", bluePrintContext)
- // Validate the Generated BluePrints
- val valid = bluePrintValidatorService.validateBluePrints(targetPath)
+ // Validate the Generated Blueprints
+ val valid = bluePrintValidatorService.validateBlueprints(targetPath)
Assert.assertTrue("blueprint($basePath) validation failed ", valid)
// Enable this to get the enhanced zip file
import org.junit.runners.MethodSorters
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.DesignerApiTestConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ModelType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
val content = JacksonUtils.getClassPathFileContent("model_type/data_type/datatype-property.json")
var modelType = ModelType()
- modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
- modelType.derivedFrom = BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT
+ modelType.definitionType = BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ modelType.derivedFrom = BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT
modelType.description = "Definition for Sample Datatype "
modelType.definition = JacksonUtils.jsonNode(content)
modelType.modelName = modelName
modelType.version = "1.0.0"
modelType.tags = (
- "test-datatype ," + BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT + "," +
- BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ "test-datatype ," + BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT + "," +
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
)
modelType.updatedBy = "xxxxxx@xxx.com"
modelType = modelTypeHandler!!.saveModel(modelType)
Assert.assertNotNull("Failed to get response for api call getModelByName ", dbModelType)
Assert.assertNotNull("Failed to get Id for api call getModelByName ", dbModelType!!.modelName)
- val dbDatatypeModelTypes = modelTypeHandler.getModelTypeByDefinitionType(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
+ val dbDatatypeModelTypes = modelTypeHandler.getModelTypeByDefinitionType(BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
Assert.assertNotNull("Failed to find getModelTypeByDefinitionType by tags", dbDatatypeModelTypes)
Assert.assertTrue("Failed to find getModelTypeByDefinitionType by count", dbDatatypeModelTypes.size > 0)
- val dbModelTypeByDerivedFroms = modelTypeHandler.getModelTypeByDerivedFrom(BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT)
+ val dbModelTypeByDerivedFroms = modelTypeHandler.getModelTypeByDerivedFrom(BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT)
Assert.assertNotNull("Failed to find getModelTypeByDerivedFrom by tags", dbModelTypeByDerivedFroms)
Assert.assertTrue("Failed to find getModelTypeByDerivedFrom by count", dbModelTypeByDerivedFroms.size > 0)
}
import org.junit.runners.MethodSorters
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.DesignerApiTestConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.domain.ModelType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
val content = normalizedFile("./src/test/resources/model_type/data_type/datatype-property.json")
.readText(Charset.defaultCharset())
val modelType = ModelType()
- modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
- modelType.derivedFrom = BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT
+ modelType.definitionType = BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ modelType.derivedFrom = BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT
modelType.description = "Definition for Sample Datatype "
modelType.definition = JacksonUtils.jsonNode(content)
modelType.modelName = modelName
modelType.version = "1.0.0"
modelType.tags = (
- "test-datatype ," + BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT + "," +
- BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
+ "test-datatype ," + BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT + "," +
+ BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
)
modelType.updatedBy = "xxxxxx@xxx.com"
Assert.assertNotNull("Failed to findByModelName ", dbFindByModelName)
val dbFindByDefinitionType =
- modelTypeReactRepository.findByDefinitionType(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE).collectList().block()
+ modelTypeReactRepository.findByDefinitionType(BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE).collectList().block()
Assert.assertNotNull("Failed to findByDefinitionType ", dbFindByDefinitionType)
Assert.assertTrue("Failed to findByDefinitionType count", dbFindByDefinitionType!!.size > 0)
- val dbFindByDerivedFrom = modelTypeReactRepository.findByDerivedFrom(BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT).collectList().block()
+ val dbFindByDerivedFrom = modelTypeReactRepository.findByDerivedFrom(BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT).collectList().block()
Assert.assertNotNull("Failed to find findByDerivedFrom", dbFindByDerivedFrom)
Assert.assertTrue("Failed to find findByDerivedFrom by count", dbFindByDerivedFrom!!.size > 0)
Assert.assertTrue("Failed to findByModelNameIn by count", dbFindByModelNameIn!!.size > 0)
val dbFindByDefinitionTypeIn =
- modelTypeReactRepository.findByDefinitionTypeIn(Arrays.asList(BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)).collectList().block()
+ modelTypeReactRepository.findByDefinitionTypeIn(Arrays.asList(BlueprintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)).collectList().block()
Assert.assertNotNull("Failed to findByDefinitionTypeIn", dbFindByDefinitionTypeIn)
Assert.assertTrue("Failed to findByDefinitionTypeIn by count", dbFindByDefinitionTypeIn!!.size > 0)
val dbFindByDerivedFromIn =
- modelTypeReactRepository.findByDerivedFromIn(Arrays.asList(BluePrintConstants.MODEL_TYPE_DATATYPES_ROOT)).collectList().block()
+ modelTypeReactRepository.findByDerivedFromIn(Arrays.asList(BlueprintConstants.MODEL_TYPE_DATATYPES_ROOT)).collectList().block()
Assert.assertNotNull("Failed to find findByDerivedFromIn", dbFindByDerivedFromIn)
Assert.assertTrue("Failed to find findByDerivedFromIn by count", dbFindByDerivedFromIn!!.size > 0)
}
import java.util.UUID
import kotlin.test.assertTrue
-class BluePrintEnhancerUtilsTest {
+class BlueprintEnhancerUtilsTest {
private val blueprintDir = "./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
private val blueprintArchivePath: String = "./target/blueprints/archive"
val enhanceId = UUID.randomUUID().toString()
val blueprintArchiveLocation = normalizedPathName(blueprintArchivePath, enhanceId)
val blueprintEnrichmentLocation = normalizedPathName(blueprintEnrichmentPath, enhanceId)
- BluePrintEnhancerUtils.copyFilePartToEnhanceDir(filePart, blueprintArchiveLocation, blueprintEnrichmentLocation)
- BluePrintEnhancerUtils.compressEnhanceDirAndReturnFilePart(blueprintEnrichmentLocation, blueprintArchiveLocation)
+ BlueprintEnhancerUtils.copyFilePartToEnhanceDir(filePart, blueprintArchiveLocation, blueprintEnrichmentLocation)
+ BlueprintEnhancerUtils.compressEnhanceDirAndReturnFilePart(blueprintEnrichmentLocation, blueprintArchiveLocation)
}
}
}
@Value("#{'\${cdslistener.healthcheck.mapping-service-name-with-service-link:}'.split(']')}")
private val cdsListenerServiceMapping: List<String>? = null
- open fun getBluePrintBaseURL(): String? {
+ open fun getBlueprintBaseURL(): String? {
return bluePrintProcessorBaseURL
}
return cdsListenerBaseURL
}
- open fun getBluePrintServiceInformation(): List<ServiceEndpoint> {
+ open fun getBlueprintServiceInformation(): List<ServiceEndpoint> {
val serviceName = ServiceName.BLUEPRINT
return getListOfServiceEndPoints(blueprintprocessorServiceMapping, serviceName)
}
*/
abstract class AbstractHealthCheck(private val endPointExecution: EndPointExecution) {
- private var logger = LoggerFactory.getLogger(BluePrintProcessorHealthCheck::class.java)
+ private var logger = LoggerFactory.getLogger(BlueprintProcessorHealthCheck::class.java)
private fun retrieveSystemStatus(list: List<ServiceEndpoint>): HealthApiResponse {
val healthApiResponse: HealthApiResponse
* @version 1.0
*/
@Service
-open class BluePrintProcessorHealthCheck(
+open class BlueprintProcessorHealthCheck(
private val endPointExecution: EndPointExecution,
private val healthCheckProperties: HealthCheckProperties
) :
AbstractHealthCheck(endPointExecution) {
override fun setupServiceEndpoint(): List<ServiceEndpoint> {
- return healthCheckProperties.getBluePrintServiceInformation()
+ return healthCheckProperties.getBlueprintServiceInformation()
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.domain.HealthCheckStatus
import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.domain.ServiceEndpoint
import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.service.EndPointExecution
-import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.service.health.BluePrintProcessorHealthCheck
+import org.onap.ccsdk.cds.blueprintsprocessor.healthapi.service.health.BlueprintProcessorHealthCheck
import org.onap.ccsdk.cds.blueprintsprocessor.rest.BasicAuthRestClientProperties
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BasicAuthRestClientService
import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
@InjectMocks
private var endPointExecution: EndPointExecution? = null
- private var bluePrintProcessorHealthCheck: BluePrintProcessorHealthCheck? = null
+ private var bluePrintProcessorHealthCheck: BlueprintProcessorHealthCheck? = null
@Before
fun setup() {
endPointExecution = Mockito.spy(endPointExecution!!)
- Mockito.`when`(healthCheckProperties!!.getBluePrintServiceInformation()).thenReturn(
+ Mockito.`when`(healthCheckProperties!!.getBlueprintServiceInformation()).thenReturn(
Arrays.asList(
ServiceEndpoint("Execution service ", "http://cds-blueprints-processor-http:8080/api/v1/execution-service/health-check"),
ServiceEndpoint("Resources service", "http://cds-blueprints-processor-http:8080/api/v1/resources/health-check"),
)
)
- bluePrintProcessorHealthCheck = BluePrintProcessorHealthCheck(endPointExecution!!, healthCheckProperties)
+ bluePrintProcessorHealthCheck = BlueprintProcessorHealthCheck(endPointExecution!!, healthCheckProperties)
}
@Test
import org.springframework.web.bind.annotation.RestController
/**
- * Exposes API for checking Metrics of BluePrint processor and CDSListener.
+ * Exposes API for checking Metrics of Blueprint processor and CDSListener.
*
* @author Shaaban Ebrahim
* @version 1.0
@RequestMapping("/api/v1/combinedMetrics")
@Api(
value = "/api/v1/combinedMetrics",
- description = "gather all Metrics info from BluePrint and CDSListener"
+ description = "gather all Metrics info from Blueprint and CDSListener"
)
open class CombinedMetrics(private val combinedMetricsService: CombinedMetricsService) {
import org.springframework.stereotype.Service
/**
- *Service for combined health (BluePrintProcessor and CDSListener)
+ *Service for combined health (BlueprintProcessor and CDSListener)
*
* @author Shaaban Ebrahim
* @version 1.0
private fun setupServiceEndpoint(): List<ServiceEndpoint> {
return listOf(
- ServiceEndpoint("BluePrintProcessor Health Check ", healthCheckProperties.getBluePrintBaseURL() + "actuator/health"),
+ ServiceEndpoint("BlueprintProcessor Health Check ", healthCheckProperties.getBlueprintBaseURL() + "actuator/health"),
ServiceEndpoint("CDSListener Health Check", healthCheckProperties.getCDSListenerBaseURL() + "actuator/health")
)
}
import org.springframework.stereotype.Service
/**
- *Service for combined Metrics for CDS Listener and BluePrintProcessor
+ *Service for combined Metrics for CDS Listener and BlueprintProcessor
*
* @author Shaaban Ebrahim
* @version 1.0
private fun setupServiceEndpoint(): List<ServiceEndpoint> {
return listOf(
- ServiceEndpoint("BluePrintProcessor metrics", healthCheckProperties.getBluePrintBaseURL() + "/actuator/metrics"),
+ ServiceEndpoint("BlueprintProcessor metrics", healthCheckProperties.getBlueprintBaseURL() + "/actuator/metrics"),
ServiceEndpoint("CDS Listener metrics", healthCheckProperties.getCDSListenerBaseURL() + "/actuator/metrics")
)
}
/*
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentScriptExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest
import org.springframework.context.annotation.ComponentScan
@RunWith(SpringRunner::class)
@WebFluxTest
@ContextConfiguration(
- classes = [BluePrintRuntimeService::class, BluePrintCoreConfiguration::class,
- BluePrintCatalogService::class, ComponentScriptExecutor::class]
+ classes = [BlueprintRuntimeService::class, BlueprintCoreConfiguration::class,
+ BlueprintCatalogService::class, ComponentScriptExecutor::class]
)
@ComponentScan(basePackages = ["org.onap.ccsdk.cds.blueprintsprocessor", "org.onap.ccsdk.cds.controllerblueprints"])
@TestPropertySource(locations = ["classpath:application-test.properties"])
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.db.ResourceResolution
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.db.ResourceResolutionDBService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
resourceAssignment.dictionaryName = "dd$prefix"
resourceAssignment.dictionarySource = "source$prefix"
resourceAssignment.version = 2
- resourceAssignment.status = BluePrintConstants.STATUS_SUCCESS
+ resourceAssignment.status = BlueprintConstants.STATUS_SUCCESS
resourceAssignment.property = property
return resourceAssignment
}
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
import org.onap.ccsdk.cds.controllerblueprints.core.deleteDir
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest
@WebFluxTest
@ContextConfiguration(
classes = [
- TestDatabaseConfiguration::class, BluePrintCoreConfiguration::class,
- BluePrintCatalogService::class, ErrorCatalogTestConfiguration::class
+ TestDatabaseConfiguration::class, BlueprintCoreConfiguration::class,
+ BlueprintCatalogService::class, ErrorCatalogTestConfiguration::class
]
)
@ComponentScan(basePackages = ["org.onap.ccsdk.cds.blueprintsprocessor", "org.onap.ccsdk.cds.controllerblueprints"])
package org.onap.ccsdk.cds.blueprintsprocessor.resource.api
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.PrimaryDatabaseConfiguration
import org.springframework.context.annotation.Bean
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = [
"org.onap.ccsdk.cds.blueprintsprocessor.db.primary",
import io.grpc.Status
import io.grpc.stub.StreamObserver
import kotlinx.coroutines.runBlocking
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.toJava
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
import org.onap.ccsdk.cds.error.catalog.core.ErrorCatalogCodes
import javax.annotation.PreDestroy
@Service
-open class BluePrintProcessingGRPCHandler(
- private val bluePrintCoreConfiguration: BluePrintCoreConfiguration,
+open class BlueprintProcessingGRPCHandler(
+ private val bluePrintCoreConfiguration: BlueprintCoreConfiguration,
private val executionServiceHandler: ExecutionServiceHandler,
private val errorCatalogService: ErrorCatalogService
) :
- BluePrintProcessingServiceGrpc.BluePrintProcessingServiceImplBase() {
+ BlueprintProcessingServiceGrpc.BlueprintProcessingServiceImplBase() {
- private val log = LoggerFactory.getLogger(BluePrintProcessingGRPCHandler::class.java)
+ private val log = LoggerFactory.getLogger(BlueprintProcessingGRPCHandler::class.java)
private val ph = Phaser(1)
override fun onError(error: Throwable) {
log.debug("Fail to process message", error)
- if (error is BluePrintProcessorException) onErrorCatalog(error) else onError(error)
+ if (error is BlueprintProcessorException) onErrorCatalog(error) else onError(error)
}
fun onError(error: Exception) {
)
}
- fun onErrorCatalog(error: BluePrintProcessorException) {
+ fun onErrorCatalog(error: BlueprintProcessorException) {
if (error.protocol == "") {
error.grpc(ErrorCatalogCodes.GENERIC_FAILURE)
}
@PreDestroy
fun preDestroy() {
- val name = "BluePrintProcessingGRPCHandler"
+ val name = "BlueprintProcessingGRPCHandler"
log.info("Starting to shutdown $name waiting for in-flight requests to finish ...")
ph.arriveAndAwaitAdvance()
log.info("Done waiting in $name")
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BluePrintMessageLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageConsumerService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.jsonAsType
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.updateErrorMessage
havingValue = "true"
)
@Service
-open class BluePrintProcessingKafkaConsumer(
- private val bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService,
+open class BlueprintProcessingKafkaConsumer(
+ private val bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService,
private val executionServiceHandler: ExecutionServiceHandler
) {
- val log = logger(BluePrintProcessingKafkaConsumer::class)
+ val log = logger(BlueprintProcessingKafkaConsumer::class)
private val ph = Phaser(1)
blueprintMessageConsumerService = try {
bluePrintMessageLibPropertyService
.blueprintMessageConsumerService(CONSUMER_SELECTOR)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Failed creating Kafka consumer message service."
throw e.updateErrorMessage(
SelfServiceApiDomains.SELF_SERVICE_API, errorMsg,
"Wrong Kafka selector provided or internal error in Kafka service."
)
} catch (e: Exception) {
- throw BluePrintProcessorException("failed to create consumer service ${e.message}")
+ throw BlueprintProcessorException("failed to create consumer service ${e.message}")
}
/** Get the Message Producer Service **/
val blueprintMessageProducerService = try {
bluePrintMessageLibPropertyService
.blueprintMessageProducerService(PRODUCER_SELECTOR)
- } catch (e: BluePrintProcessorException) {
+ } catch (e: BlueprintProcessorException) {
val errorMsg = "Failed creating Kafka producer message service."
throw e.updateErrorMessage(
SelfServiceApiDomains.SELF_SERVICE_API, errorMsg,
"Wrong Kafka selector provided or internal error in Kafka service."
)
} catch (e: Exception) {
- throw BluePrintProcessorException("failed to create producer service ${e.message}")
+ throw BlueprintProcessorException("failed to create producer service ${e.message}")
}
launch {
import org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api.utils.cbaMetricTags
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractServiceFunction
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.config.BluePrintLoadConfiguration
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowExecutionService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.config.BlueprintLoadConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowExecutionService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import java.util.stream.Collectors
@Service
class ExecutionServiceHandler(
- private val bluePrintLoadConfiguration: BluePrintLoadConfiguration,
- private val blueprintsProcessorCatalogService: BluePrintCatalogService,
+ private val bluePrintLoadConfiguration: BlueprintLoadConfiguration,
+ private val blueprintsProcessorCatalogService: BlueprintCatalogService,
private val bluePrintWorkflowExecutionService:
- BluePrintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput>,
+ BlueprintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput>,
private val publishAuditService: PublishAuditService,
private val meterRegistry: MeterRegistry
) {
val basePath = blueprintsProcessorCatalogService.getFromDatabase(blueprintName, blueprintVersion)
log.info("blueprint base path $basePath")
- val blueprintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(requestId, basePath.toString())
+ val blueprintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(requestId, basePath.toString())
- executionServiceOutput = bluePrintWorkflowExecutionService.executeBluePrintWorkflow(
+ executionServiceOutput = bluePrintWorkflowExecutionService.executeBlueprintWorkflow(
blueprintRuntimeService,
executionServiceInput, hashMapOf()
)
- val errors = blueprintRuntimeService.getBluePrintError().errors
+ val errors = blueprintRuntimeService.getBlueprintError().errors
if (errors.isNotEmpty()) {
val errorMessage = errors.stream().map { it.toString() }.collect(Collectors.joining(", "))
setErrorStatus(errorMessage, executionServiceOutput.status)
/** If no blueprint is needed, then get the Service function instance mapping to the action name and execute it */
suspend fun executeServiceFunction(executionServiceInput: ExecutionServiceInput): ExecutionServiceOutput {
val actionName = executionServiceInput.actionIdentifiers.actionName
- val instance = Blue
PrintDependencyService.instance<AbstractServiceFunction>(actionName)
+ val instance = Blue
printDependencyService.instance<AbstractServiceFunction>(actionName)
checkNotNull(instance) { "failed to initialize service function($actionName)" }
instance.actionName = actionName
return instance.applyNB(executionServiceInput)
status.errorMessage = errorMessage
status.eventType = EventType.EVENT_COMPONENT_FAILURE.name
status.code = 500
- status.message = BluePrintConstants.STATUS_FAILURE
+ status.message = BlueprintConstants.STATUS_FAILURE
}
private fun response(
} else {
status.eventType = EventType.EVENT_COMPONENT_PROCESSING.name
status.code = 200
- status.message = BluePrintConstants.STATUS_PROCESSING
+ status.message = BlueprintConstants.STATUS_PROCESSING
}
executionServiceOutput.status = status
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
-import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BluePrintMessageLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageLibPropertyService
import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageProducerService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.common.ApplicationConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.service.PropertyAssignmentService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.PropertyDefinitionUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
)
@Service
class KafkaPublishAuditService(
- private val bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService,
- private val blueprintsProcessorCatalogService: BluePrintCatalogService
+ private val bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService,
+ private val blueprintsProcessorCatalogService: BlueprintCatalogService
) : PublishAuditService {
private var inputInstance: BlueprintMessageProducerService? = null
val basePath = blueprintsProcessorCatalogService.getFromDatabase(blueprintName, blueprintVersion)
- val blueprintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(requestId, basePath.toString())
+ val blueprintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(requestId, basePath.toString())
val blueprintContext = blueprintRuntimeService.bluePrintContext()
val workflowSteps = blueprintContext.workflowByName(workflowName).steps
val nodeTemplate = blueprintContext.nodeTemplateByName(nodeTemplateName)
/** We need to check in his Node Template Dependencies is case of a Node Template DG */
- if (nodeTemplate.type == BluePrintConstants.NODE_TEMPLATE_TYPE_DG) {
+ if (nodeTemplate.type == BlueprintConstants.NODE_TEMPLATE_TYPE_DG) {
val dependencyNodeTemplate =
- nodeTemplate.properties?.get(BluePrintConstants.PROPERTY_DG_DEPENDENCY_NODE_TEMPLATE) as ArrayNode
+ nodeTemplate.properties?.get(BlueprintConstants.PROPERTY_DG_DEPENDENCY_NODE_TEMPLATE) as ArrayNode
dependencyNodeTemplate.forEach { dependencyNodeTemplateName ->
clonedExecutionServiceInput = hideSensitiveDataFromResourceResolution(
blueprintRuntimeService,
* @return [executionServiceInput] with sensitive inputs replaced by a generic string
*/
private suspend fun hideSensitiveDataFromResourceResolution(
- blueprintRuntimeService: BluePrintRuntimeService<MutableMap<String, JsonNode>>,
- blueprintContext: BluePrintContext,
+ blueprintRuntimeService: BlueprintRuntimeService<MutableMap<String, JsonNode>>,
+ blueprintContext: BlueprintContext,
executionServiceInput: ExecutionServiceInput,
workflowName: String,
nodeTemplateName: String
): ExecutionServiceInput {
val nodeTemplate = blueprintContext.nodeTemplateByName(nodeTemplateName)
- if (nodeTemplate.type == BluePrintConstants.NODE_TEMPLATE_TYPE_COMPONENT_RESOURCE_RESOLUTION) {
+ if (nodeTemplate.type == BlueprintConstants.NODE_TEMPLATE_TYPE_COMPONENT_RESOURCE_RESOLUTION) {
val interfaceName = blueprintContext.nodeTemplateFirstInterfaceName(nodeTemplateName)
val operationName = blueprintContext.nodeTemplateFirstInterfaceFirstOperationName(nodeTemplateName)
val artifactPrefixNamesNode = propertyAssignments[ResourceResolutionConstants.INPUT_ARTIFACT_PREFIX_NAMES]
val propertyAssignmentService = PropertyAssignmentService(blueprintRuntimeService)
val artifactPrefixNamesNodeValue = propertyAssignmentService.resolveAssignmentExpression(
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
nodeTemplateName,
ResourceResolutionConstants.INPUT_ARTIFACT_PREFIX_NAMES,
artifactPrefixNamesNode!!
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
import org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api.SelfServiceMetricConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.springframework.http.HttpStatus
import org.springframework.http.codec.multipart.FilePart
import org.springframework.util.StringUtils
const val INTERNAL_SERVER_ERROR_HTTP_STATUS_CODE = 500
-@Throws(BluePrintException::class, IOException::class)
+@Throws(BlueprintException::class, IOException::class)
fun saveCBAFile(filePart: FilePart, targetDirectory: Path): Path {
val fileName = StringUtils.cleanPath(filePart.filename())
if (StringUtils.getFilenameExtension(fileName) != "zip") {
- throw BluePrintException("Invalid file extension required ZIP")
+ throw BlueprintException("Invalid file extension required ZIP")
}
val changedFileName = UUID.randomUUID().toString() + ".zip"
package org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api.validation
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.cds.controllerblueprints.validation.BluePrintDesignTimeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.validation.BlueprintDesignTimeValidatorService
import org.onap.ccsdk.cds.controllerblueprints.validation.extension.ResourceDefinitionValidator
import org.springframework.stereotype.Service
@Service("bluePrintRuntimeValidatorService")
-open class BluePrintRuntimeValidatorService(
- bluePrintTypeValidatorService: BluePrintTypeValidatorService,
+open class BlueprintRuntimeValidatorService(
+ bluePrintTypeValidatorService: BlueprintTypeValidatorService,
resourceDefinitionValidator: ResourceDefinitionValidator
) :
- BluePrintDesignTimeValidatorService(bluePrintTypeValidatorService, resourceDefinitionValidator)
+ BlueprintDesignTimeValidatorService(bluePrintTypeValidatorService, resourceDefinitionValidator)
import org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
-import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
import org.slf4j.LoggerFactory
]
)
@TestPropertySource(locations = ["classpath:application-test.properties"])
-class BluePrintProcessingGRPCHandlerTest {
+class BlueprintProcessingGRPCHandlerTest {
- private val log = LoggerFactory.getLogger(BluePrintProcessingGRPCHandlerTest::class.java)
+ private val log = LoggerFactory.getLogger(BlueprintProcessingGRPCHandlerTest::class.java)
@MockBean
lateinit var meterRegistry: MeterRegistry
val grpcServerRule = GrpcServerRule().directExecutor()
@Autowired
- lateinit var bluePrintProcessingGRPCHandler: BluePrintProcessingGRPCHandler
+ lateinit var bluePrintProcessingGRPCHandler: BlueprintProcessingGRPCHandler
lateinit var requestObs: StreamObserver<ExecutionServiceInput>
fun init() {
grpcServerRule.serviceRegistry.addService(bluePrintProcessingGRPCHandler)
- val blockingStub = BluePrintProcessingServiceGrpc.newStub(grpcServerRule.channel)
+ val blockingStub = BlueprintProcessingServiceGrpc.newStub(grpcServerRule.channel)
requestObs = blockingStub.process(object : StreamObserver<ExecutionServiceOutput> {
override fun onNext(executionServiceOuput: ExecutionServiceOutput) {
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
-import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
import org.springframework.test.context.ContextConfiguration
@ContextConfiguration(
classes = [SelfServiceApiTestConfiguration::class, ErrorCatalogTestConfiguration::class]
)
-class BluePrintProcessingIntegrationTest {
+class BlueprintProcessingIntegrationTest {
- private val log = logger(BluePrintProcessingIntegrationTest::class)
+ private val log = logger(BlueprintProcessingIntegrationTest::class)
/** This is Integration test sample, Do not enable this test case in server build, this is for local desktop testing*/
// @Test
val basicAuthGrpcClientService = TokenAuthGrpcClientService(tokenAuthGrpcClientProperties)
val channel = basicAuthGrpcClientService.channel()
- val stub = BluePrintProcessingServiceGrpc.newStub(channel)
+ val stub = BlueprintProcessingServiceGrpc.newStub(channel)
repeat(1) {
val requestObs = stub.process(object : StreamObserver<ExecutionServiceOutput> {
override fun onNext(executionServiceOuput: ExecutionServiceOutput) {
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertiesService
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintPropertyConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.message.BluePrintMessageLibConfiguration
-import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BluePrintMessageLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.message.BlueprintMessageLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.message.service.BlueprintMessageLibPropertyService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.test.context.ContextConfiguration
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- BluePrintMessageLibConfiguration::class, SelfServiceApiTestConfiguration::class,
- BluePrintPropertyConfiguration::class, BluePrintPropertiesService::class, ErrorCatalogTestConfiguration::class
+ BlueprintMessageLibConfiguration::class, SelfServiceApiTestConfiguration::class,
+ BlueprintPropertyConfiguration::class, BlueprintPropertiesService::class, ErrorCatalogTestConfiguration::class
]
)
@TestPropertySource(locations = ["classpath:application-test.properties"])
-class BluePrintProcessingKafkaConsumerTest {
+class BlueprintProcessingKafkaConsumerTest {
@MockBean
lateinit var meterRegistry: MeterRegistry
@Autowired
- lateinit var bluePrintMessageLibPropertyService: BluePrintMessageLibPropertyService
+ lateinit var bluePrintMessageLibPropertyService: BlueprintMessageLibPropertyService
@Test
fun testExecutionInputMessageConsumer() {
coEvery { executionServiceHandle.doProcess(any()) } returns mockk()
- val bluePrintProcessingKafkaConsumer = BluePrintProcessingKafkaConsumer(
+ val bluePrintProcessingKafkaConsumer = BlueprintProcessingKafkaConsumer(
bluePrintMessageLibPropertyService,
executionServiceHandle
)
import kotlinx.coroutines.runBlocking
import org.junit.Test
import org.junit.runner.RunWith
-import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.core.compress
import org.onap.ccsdk.cds.controllerblueprints.core.deleteDir
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintCatalogService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintCatalogService
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
@WebFluxTest
@ContextConfiguration(
classes = [
- ExecutionServiceHandler::class, BluePrintCoreConfiguration::class,
- BluePrintCatalogService::class, SelfServiceApiTestConfiguration::class,
+ ExecutionServiceHandler::class, BlueprintCoreConfiguration::class,
+ BlueprintCatalogService::class, SelfServiceApiTestConfiguration::class,
ErrorCatalogTestConfiguration::class, SimpleMeterRegistry::class
]
)
class ExecutionServiceControllerTest {
@Autowired
- lateinit var blueprintsProcessorCatalogService: BluePrintCatalogService
+ lateinit var blueprintsProcessorCatalogService: BlueprintCatalogService
@Autowired
lateinit var webTestClient: WebTestClient
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractServiceFunction
import org.onap.ccsdk.cds.controllerblueprints.core.jsonAsJsonType
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.ApplicationContext
@Before
fun init() {
- BluePrintDependencyService.inject(applicationContext)
+ BlueprintDependencyService.inject(applicationContext)
}
@Test
package org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api
-import org.onap.ccsdk.cds.blueprintsprocessor.db.BluePrintDBLibConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.db.BlueprintDBLibConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.db.PrimaryDataSourceProperties
import org.onap.ccsdk.cds.blueprintsprocessor.db.primary.PrimaryDatabaseConfiguration
import org.springframework.context.annotation.Bean
import javax.sql.DataSource
@Configuration
-@Import(BluePrintDBLibConfiguration::class)
+@Import(BlueprintDBLibConfiguration::class)
@EnableJpaRepositories(
basePackages = [
"org.onap.ccsdk.cds.blueprintsprocessor.db.primary",
import org.junit.Test
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api.mock.MockResourceSource
-import org.onap.ccsdk.cds.controllerblueprints.validation.BluePrintValidationConfiguration
+import org.onap.ccsdk.cds.controllerblueprints.validation.BlueprintValidationConfiguration
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
import org.springframework.test.context.junit4.SpringRunner
@RunWith(SpringRunner::class)
@ContextConfiguration(
classes = [
- BluePrintRuntimeValidatorService::class,
- BluePrintValidationConfiguration::class, MockResourceSource::class
+ BlueprintRuntimeValidatorService::class,
+ BlueprintValidationConfiguration::class, MockResourceSource::class
]
)
-class BluePrintRuntimeValidatorServiceTest {
+class BlueprintRuntimeValidatorServiceTest {
@Autowired
- lateinit var bluePrintRuntimeValidatorService: BluePrintRuntimeValidatorService
+ lateinit var bluePrintRuntimeValidatorService: BlueprintRuntimeValidatorService
@Test
fun testBlueprintRuntimeValidation() {
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
assertNotNull(bluePrintRuntimeValidatorService, " failed to initilize bluePrintRuntimeValidatorService")
- bluePrintRuntimeValidatorService.validateBluePrints(blueprintBasePath)
+ bluePrintRuntimeValidatorService.validateBlueprints(blueprintBasePath)
}
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.Status
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
import org.onap.ccsdk.cds.blueprintsprocessor.core.cluster.executeWithLock
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.CDS_LOCK_GROUP
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotBlank
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.jsonPathParse
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
import org.onap.ccsdk.cds.controllerblueprints.core.readNBLines
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintVelocityTemplateService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintVelocityTemplateService
import org.slf4j.LoggerFactory
/**
lateinit var executionServiceInput: ExecutionServiceInput
var executionServiceOutput = ExecutionServiceOutput()
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
- lateinit var bluePrintClusterService: BluePrintClusterService
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
+ lateinit var bluePrintClusterService: BlueprintClusterService
lateinit var implementation: Implementation
lateinit var processId: String
lateinit var workflowName: String
log.info("preparing request id($processId) for workflow($workflowName) step($stepName)")
- nodeTemplateName = this.operationInputs.getAsString(BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE)
+ nodeTemplateName = this.operationInputs.getAsString(BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE)
check(nodeTemplateName.isNotEmpty()) { "couldn't get NodeTemplate name for step($stepName)" }
- interfaceName = this.operationInputs.getAsString(BluePrintConstants.PROPERTY_CURRENT_INTERFACE)
+ interfaceName = this.operationInputs.getAsString(BlueprintConstants.PROPERTY_CURRENT_INTERFACE)
check(interfaceName.isNotEmpty()) { "couldn't get Interface name for step($stepName)" }
- operationName = this.operationInputs.getAsString(BluePrintConstants.PROPERTY_CURRENT_OPERATION)
+ operationName = this.operationInputs.getAsString(BlueprintConstants.PROPERTY_CURRENT_OPERATION)
check(operationName.isNotEmpty()) { "couldn't get Operation name for step($stepName)" }
/** Get the Implementation Details */
/** Resolve and validate lock properties */
implementation.lock?.apply {
val resolvedValues = bluePrintRuntimeService.resolvePropertyAssignments(
- BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
+ BlueprintConstants.MODEL_DEFINITION_TYPE_NODE_TEMPLATE,
interfaceName,
mutableMapOf("key" to this.key, "acquireTimeout" to this.acquireTimeout)
)
// Set the Default Step Status
status.eventType = EventType.EVENT_COMPONENT_EXECUTED.name
} catch (e: Exception) {
- status.message = BluePrintConstants.STATUS_FAILURE
+ status.message = BlueprintConstants.STATUS_FAILURE
status.eventType = EventType.EVENT_COMPONENT_FAILURE.name
}
executionServiceOutput.status = status
fun getOperationInput(key: String): JsonNode {
return operationInputs[key]
- ?: throw BluePrintProcessorException("couldn't get the operation input($key) value.")
+ ?: throw BlueprintProcessorException("couldn't get the operation input($key) value.")
}
fun getOptionalOperationInput(key: String): JsonNode? {
}
fun addError(type: String, name: String, error: String) {
- bluePrintRuntimeService.getBluePrintError().addError(type, name, error)
+ bluePrintRuntimeService.getBlueprintError().addError(type, name, error)
}
fun addError(error: String) {
- bluePrintRuntimeService.getBluePrintError().addError(error)
+ bluePrintRuntimeService.getBlueprintError().addError(error)
}
/**
suspend fun relationshipProperty(relationshipName: String, propertyName: String): JsonNode {
return bluePrintRuntimeService.resolveRelationshipTemplateProperties(relationshipName).get(propertyName)
- ?: throw BluePrintProcessorException("failed to get relationship($relationshipName) property($propertyName)")
+ ?: throw BlueprintProcessorException("failed to get relationship($relationshipName) property($propertyName)")
}
suspend fun mashTemplateNData(artifactName: String, json: String): String {
val content = artifactContent(artifactName)
- return BluePrintVelocityTemplateService.generateContent(content, json)
+ return BlueprintVelocityTemplateService.generateContent(content, json)
}
suspend fun readLinesFromArtifact(artifactName: String): List<String> {
import com.fasterxml.jackson.databind.JsonNode
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.slf4j.LoggerFactory
abstract class AbstractScriptComponentFunction : AbstractComponentFunction() {
@Deprecated("Dependencies will be resolved dynamically")
open fun <T> functionDependencyInstanceAsType(name: String): T {
return functionDependencyInstances[name] as? T
- ?: throw BluePrintProcessorException("couldn't get script property instance ($name)")
+ ?: throw BlueprintProcessorException("couldn't get script property instance ($name)")
}
fun checkDynamicProperties(key: String): Boolean {
suspend fun executeScript(executionServiceInput: ExecutionServiceInput) {
return when (scriptType) {
- BluePrintConstants.SCRIPT_JYTHON -> {
+ BlueprintConstants.SCRIPT_JYTHON -> {
executeScriptBlocking(executionServiceInput)
}
else -> {
*/
final override fun apply(executionServiceInput: ExecutionServiceInput): ExecutionServiceOutput {
- throw BluePrintException("Not Implemented, use applyNB method")
+ throw BlueprintException("Not Implemented, use applyNB method")
}
final override fun prepareRequest(executionRequest: ExecutionServiceInput): ExecutionServiceInput {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
final override fun prepareResponse(): ExecutionServiceOutput {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
final override suspend fun applyNB(executionServiceInput: ExecutionServiceInput): ExecutionServiceOutput {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
final override suspend fun prepareRequestNB(executionRequest: ExecutionServiceInput): ExecutionServiceInput {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
final override suspend fun prepareResponseNB(): ExecutionServiceOutput {
- throw BluePrintException("Not Implemented required")
+ throw BlueprintException("Not Implemented required")
}
override fun process(executionRequest: ExecutionServiceInput) {
- throw BluePrintException("Not Implemented, child class will implement this")
+ throw BlueprintException("Not Implemented, child class will implement this")
}
override fun recover(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- throw BluePrintException("Not Implemented, child class will implement this")
+ throw BlueprintException("Not Implemented, child class will implement this")
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.Status
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintFunctionNode
import org.onap.ccsdk.cds.controllerblueprints.core.jsonPathParse
import org.onap.ccsdk.cds.controllerblueprints.core.logger
// Set the Default Step Status
status.eventType = EventType.EVENT_COMPONENT_EXECUTED.name
} catch (e: Exception) {
- status.message = BluePrintConstants.STATUS_FAILURE
+ status.message = BlueprintConstants.STATUS_FAILURE
status.eventType = EventType.EVENT_COMPONENT_FAILURE.name
}
executionServiceOutput.status = status
package org.onap.ccsdk.cds.blueprintsprocessor.services.execution
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.scripts.BlueprintJythonService
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintScriptsService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintScriptsService
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintFunctionNode
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintScriptsServiceImpl
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintScriptsServiceImpl
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.slf4j.LoggerFactory
import org.springframework.context.ApplicationContext
import org.springframework.stereotype.Service
}
suspend fun <T : BlueprintFunctionNode<*, *>> scriptInstance(
- bluePrintContext: BluePrintContext,
+ bluePrintContext: BlueprintContext,
scriptType: String,
scriptClassReference: String
): T {
var scriptComponent: T? = null
when (scriptType) {
- BluePrintConstants.SCRIPT_INTERNAL -> {
- val bluePrintScriptsService: BluePrintScriptsService = BluePrintScriptsServiceImpl()
+ BlueprintConstants.SCRIPT_INTERNAL -> {
+ val bluePrintScriptsService: BlueprintScriptsService = BlueprintScriptsServiceImpl()
scriptComponent = bluePrintScriptsService.scriptInstance<T>(scriptClassReference)
}
- BluePrintConstants.SCRIPT_KOTLIN -> {
- val bluePrintScriptsService: BluePrintScriptsService = BluePrintScriptsServiceImpl()
+ BlueprintConstants.SCRIPT_KOTLIN -> {
+ val bluePrintScriptsService: BlueprintScriptsService = BlueprintScriptsServiceImpl()
scriptComponent = bluePrintScriptsService.scriptInstance<T>(
bluePrintContext.rootPath,
bluePrintContext.name(), bluePrintContext.version(), scriptClassReference, false
)
}
- BluePrintConstants.SCRIPT_JYTHON -> {
+ BlueprintConstants.SCRIPT_JYTHON -> {
scriptComponent = blueprintJythonService.jythonComponentInstance(bluePrintContext, scriptClassReference) as T
}
else -> {
- throw BluePrintProcessorException("script type($scriptType) is not supported")
+ throw BlueprintProcessorException("script type($scriptType) is not supported")
}
}
return scriptComponent
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.createActionIdentifiersProto
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.createCommonHeaderProto
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.createExecutionServiceInputProto
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
val txId = UUID.randomUUID().toString()
val commonHeader = createCommonHeaderProto(
executionRequest.commonHeader.subRequestId,
- txId, BluePrintConstants.APP_NAME
+ txId, BlueprintConstants.APP_NAME
)
val actionIdentifier = createActionIdentifiersProto(blueprintName, blueprintVersion, blueprintAction)
/** set node template attribute */
val statusMessage = executionServiceOutputProto.status.message
- if (statusMessage == BluePrintConstants.STATUS_SUCCESS) {
- setAttribute(ATTRIBUTE_STATUS, BluePrintConstants.STATUS_SUCCESS.asJsonPrimitive())
+ if (statusMessage == BlueprintConstants.STATUS_SUCCESS) {
+ setAttribute(ATTRIBUTE_STATUS, BlueprintConstants.STATUS_SUCCESS.asJsonPrimitive())
} else {
val errorMessage = executionServiceOutputProto.status.errorMessage ?: "failed in remote execution"
- throw BluePrintProcessorException(errorMessage)
+ throw BlueprintProcessorException(errorMessage)
}
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError()
+ bluePrintRuntimeService.getBlueprintError()
.addError("Failed in ComponentRemoteScriptExecutor : ${runtimeException.message}")
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.services.execution
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
/** Component Extensions **/
fun ServiceTemplateBuilder.nodeTypeComponentRemoteScriptExecutor() {
- val nodeType = BluePrintTypes.nodeTypeComponentRemoteScriptExecutor()
+ val nodeType = BlueprintTypes.nodeTypeComponentRemoteScriptExecutor()
if (this.nodeTypes == null) this.nodeTypes = hashMapOf()
this.nodeTypes!![nodeType.id!!] = nodeType
}
-fun BluePrintTypes.nodeTypeComponentRemoteScriptExecutor(): NodeType {
+fun BlueprintTypes.nodeTypeComponentRemoteScriptExecutor(): NodeType {
return nodeType(
- id = "component-remote-script-executor", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_COMPONENT,
+ id = "component-remote-script-executor", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_COMPONENT,
description = "Generic Remote Script Component Executor"
) {
/** Attribute definitions */
attribute(
- ComponentRemoteScriptExecutor.ATTRIBUTE_RESPONSE_DATA, BluePrintConstants.DATA_TYPE_JSON, false,
+ ComponentRemoteScriptExecutor.ATTRIBUTE_RESPONSE_DATA, BlueprintConstants.DATA_TYPE_JSON, false,
"Remote executed response data."
)
attribute(
- ComponentRemoteScriptExecutor.ATTRIBUTE_STATUS, BluePrintConstants.DATA_TYPE_STRING, true,
+ ComponentRemoteScriptExecutor.ATTRIBUTE_STATUS, BlueprintConstants.DATA_TYPE_STRING, true,
"Remote execution status."
)
operation("ComponentRemoteScriptExecutor", "ComponentRemoteScriptExecutor Operation") {
inputs {
property(
- ComponentRemoteScriptExecutor.INPUT_SELECTOR, BluePrintConstants.DATA_TYPE_JSON,
+ ComponentRemoteScriptExecutor.INPUT_SELECTOR, BlueprintConstants.DATA_TYPE_JSON,
true, "Remote GRPC selector or DSL reference or GRPC Json config."
)
property(
- ComponentRemoteScriptExecutor.INPUT_BLUEPRINT_NAME, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentRemoteScriptExecutor.INPUT_BLUEPRINT_NAME, BlueprintConstants.DATA_TYPE_STRING,
true, "Blueprint name."
)
property(
- ComponentRemoteScriptExecutor.INPUT_BLUEPRINT_VERSION, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentRemoteScriptExecutor.INPUT_BLUEPRINT_VERSION, BlueprintConstants.DATA_TYPE_STRING,
true, "Blueprint version."
)
property(
- ComponentRemoteScriptExecutor.INPUT_BLUEPRINT_ACTION, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentRemoteScriptExecutor.INPUT_BLUEPRINT_ACTION, BlueprintConstants.DATA_TYPE_STRING,
true, "Blueprint action name."
)
property(
- ComponentRemoteScriptExecutor.INPUT_TIMEOUT, BluePrintConstants.DATA_TYPE_INTEGER,
+ ComponentRemoteScriptExecutor.INPUT_TIMEOUT, BlueprintConstants.DATA_TYPE_INTEGER,
true, "Remote execution timeout in sec."
) {
defaultValue(180)
}
property(
- ComponentRemoteScriptExecutor.INPUT_REQUEST_DATA, BluePrintConstants.DATA_TYPE_JSON,
+ ComponentRemoteScriptExecutor.INPUT_REQUEST_DATA, BlueprintConstants.DATA_TYPE_JSON,
false, "Dynamic Json Content or DSL Json reference."
)
}
outputs {
property(
- ComponentRemoteScriptExecutor.OUTPUT_STATUS, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentRemoteScriptExecutor.OUTPUT_STATUS, BlueprintConstants.DATA_TYPE_STRING,
true, "Status of the Component Execution ( success or failure )"
)
}
description: String,
block: ComponentRemoteScriptExecutorNodeTemplateBuilder.() -> Unit
) {
- val nodeTemplate = BluePrintTypes.nodeTemplateComponentRemoteScriptExecutor(
+ val nodeTemplate = BlueprintTypes.nodeTemplateComponentRemoteScriptExecutor(
id, description,
block
)
nodeTemplates!![nodeTemplate.id!!] = nodeTemplate
}
-fun BluePrintTypes.nodeTemplateComponentRemoteScriptExecutor(
+fun BlueprintTypes.nodeTemplateComponentRemoteScriptExecutor(
id: String,
description: String,
block: ComponentRemoteScriptExecutorNodeTemplateBuilder.() -> Unit
}
override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
- bluePrintRuntimeService.getBluePrintError()
+ bluePrintRuntimeService.getBlueprintError()
.addError("Failed in ComponentScriptExecutor : ${runtimeException.message}")
}
package org.onap.ccsdk.cds.blueprintsprocessor.services.execution
import com.fasterxml.jackson.databind.JsonNode
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
/** Component Extensions **/
fun ServiceTemplateBuilder.nodeTypeComponentScriptExecutor() {
- val nodeType = BluePrintTypes.nodeTypeComponentScriptExecutor()
+ val nodeType = BlueprintTypes.nodeTypeComponentScriptExecutor()
if (this.nodeTypes == null) this.nodeTypes = hashMapOf()
this.nodeTypes!![nodeType.id!!] = nodeType
}
-fun BluePrintTypes.nodeTypeComponentScriptExecutor(): NodeType {
+fun BlueprintTypes.nodeTypeComponentScriptExecutor(): NodeType {
return nodeType(
- id = "component-script-executor", version = BluePrintConstants.DEFAULT_VERSION_NUMBER,
- derivedFrom = BluePrintConstants.MODEL_TYPE_NODE_COMPONENT,
+ id = "component-script-executor", version = BlueprintConstants.DEFAULT_VERSION_NUMBER,
+ derivedFrom = BlueprintConstants.MODEL_TYPE_NODE_COMPONENT,
description = "Generic Script Component Executor"
) {
- attribute(ComponentScriptExecutor.ATTRIBUTE_RESPONSE_DATA, BluePrintConstants.DATA_TYPE_JSON, false)
- attribute(ComponentScriptExecutor.ATTRIBUTE_STATUS, BluePrintConstants.DATA_TYPE_STRING, true)
+ attribute(ComponentScriptExecutor.ATTRIBUTE_RESPONSE_DATA, BlueprintConstants.DATA_TYPE_JSON, false)
+ attribute(ComponentScriptExecutor.ATTRIBUTE_STATUS, BlueprintConstants.DATA_TYPE_STRING, true)
operation("ComponentScriptExecutor", "ComponentScriptExecutor Operation") {
inputs {
property(
- ComponentScriptExecutor.INPUT_SCRIPT_TYPE, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentScriptExecutor.INPUT_SCRIPT_TYPE, BlueprintConstants.DATA_TYPE_STRING,
true, "Script Type"
) {
- defaultValue(BluePrintConstants.SCRIPT_INTERNAL)
+ defaultValue(BlueprintConstants.SCRIPT_INTERNAL)
constrain {
validValues(
listOf(
- BluePrintConstants.SCRIPT_INTERNAL.asJsonPrimitive(),
- BluePrintConstants.SCRIPT_JYTHON.asJsonPrimitive(),
- BluePrintConstants.SCRIPT_KOTLIN.asJsonPrimitive()
+ BlueprintConstants.SCRIPT_INTERNAL.asJsonPrimitive(),
+ BlueprintConstants.SCRIPT_JYTHON.asJsonPrimitive(),
+ BlueprintConstants.SCRIPT_KOTLIN.asJsonPrimitive()
)
)
}
}
property(
- ComponentScriptExecutor.INPUT_SCRIPT_CLASS_REFERENCE, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentScriptExecutor.INPUT_SCRIPT_CLASS_REFERENCE, BlueprintConstants.DATA_TYPE_STRING,
true, "Kotlin Script class name or jython script name."
)
property(
- ComponentScriptExecutor.INPUT_DYNAMIC_PROPERTIES, BluePrintConstants.DATA_TYPE_JSON,
+ ComponentScriptExecutor.INPUT_DYNAMIC_PROPERTIES, BlueprintConstants.DATA_TYPE_JSON,
false, "Dynamic Json Content or DSL Json reference."
)
}
outputs {
property(
- ComponentScriptExecutor.OUTPUT_RESPONSE_DATA, BluePrintConstants.DATA_TYPE_JSON,
+ ComponentScriptExecutor.OUTPUT_RESPONSE_DATA, BlueprintConstants.DATA_TYPE_JSON,
false, "Output Response"
)
property(
- ComponentScriptExecutor.OUTPUT_STATUS, BluePrintConstants.DATA_TYPE_STRING,
+ ComponentScriptExecutor.OUTPUT_STATUS, BlueprintConstants.DATA_TYPE_STRING,
true, "Status of the Component Execution ( success or failure )"
)
}
description: String,
block: ComponentScriptExecutorNodeTemplateBuilder.() -> Unit
) {
- val nodeTemplate = BluePrintTypes.nodeTemplateComponentScriptExecutor(
+ val nodeTemplate = BlueprintTypes.nodeTemplateComponentScriptExecutor(
id, description,
block
)
nodeTemplates!![nodeTemplate.id!!] = nodeTemplate
}
-fun BluePrintTypes.nodeTemplateComponentScriptExecutor(
+fun BlueprintTypes.nodeTemplateComponentScriptExecutor(
id: String,
description: String,
block: ComponentScriptExecutorNodeTemplateBuilder.() -> Unit
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.RemoteScriptExecutionInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.RemoteScriptExecutionOutput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StatusType
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BluePrintGrpcClientService
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BluePrintGrpcLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BlueprintGrpcClientService
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BlueprintGrpcLibPropertyService
import org.onap.ccsdk.cds.controllerblueprints.command.api.CommandExecutorServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.command.api.ExecutionInput
import org.onap.ccsdk.cds.controllerblueprints.command.api.ExecutionOutput
havingValue = "true", matchIfMissing = false
)
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-class GrpcRemoteScriptExecutionService(private val bluePrintGrpcLibPropertyService: BluePrintGrpcLibPropertyService) :
+class GrpcRemoteScriptExecutionService(private val bluePrintGrpcLibPropertyService: BlueprintGrpcLibPropertyService) :
RemoteScriptExecutionService {
private val log = LoggerFactory.getLogger(GrpcRemoteScriptExecutionService::class.java)!!
override suspend fun init(selector: Any) {
// Get the GRPC Client Service based on selector
- val grpcClientService: BluePrintGrpcClientService = if (selector is JsonNode) {
+ val grpcClientService: BlueprintGrpcClientService = if (selector is JsonNode) {
bluePrintGrpcLibPropertyService.blueprintGrpcClientService(selector)
} else {
bluePrintGrpcLibPropertyService.blueprintGrpcClientService(selector.toString())
import kotlinx.coroutines.launch
import kotlinx.coroutines.withTimeout
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.GrpcClientProperties
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BluePrintGrpcClientService
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BluePrintGrpcLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BlueprintGrpcClientService
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BlueprintGrpcLibPropertyService
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
prefix = "blueprintsprocessor.streamingRemoteExecution", name = ["enabled"],
havingValue = "true", matchIfMissing = false
)
-class StreamingRemoteExecutionServiceImpl(private val bluePrintGrpcLibPropertyService: BluePrintGrpcLibPropertyService) :
+class StreamingRemoteExecutionServiceImpl(private val bluePrintGrpcLibPropertyService: BlueprintGrpcLibPropertyService) :
StreamingRemoteExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
private val log = logger(StreamingRemoteExecutionServiceImpl::class)
val grpcChannel = grpcChannel(selector)
/** Get Send and Receive Channel for bidirectional process method*/
- val channels = clientCallBidiStreaming(BluePrintProcessingServiceGrpc.getProcessMethod(), grpcChannel)
+ val channels = clientCallBidiStreaming(BlueprintProcessingServiceGrpc.getProcessMethod(), grpcChannel)
commChannels[txId] = channels
}
val commChannel = commChannels[txId]
- ?: throw BluePrintException("failed to create response subscription for transactionId($txId) channel")
+ ?: throw BlueprintException("failed to create response subscription for transactionId($txId) channel")
log.info("created subscription for transactionId($txId)")
*/
override suspend fun send(txId: String, input: ExecutionServiceInput) {
val sendChannel = commChannels[txId]?.requestChannel
- ?: throw BluePrintException("failed to get transactionId($txId) send channel")
+ ?: throw BlueprintException("failed to get transactionId($txId) send channel")
coroutineScope {
launch {
sendChannel.send(input)
/** Send the request */
val sendChannel = commChannels[txId]?.requestChannel
- ?: throw BluePrintException("failed to get transactionId($txId) send channel")
+ ?: throw BlueprintException("failed to get transactionId($txId) send channel")
sendChannel.send(input)
/** Receive the response with timeout */
}
suspend fun createGrpcChannel(grpcProperties: GrpcClientProperties): ManagedChannel {
- val grpcClientService: BluePrintGrpcClientService = bluePrintGrpcLibPropertyService
+ val grpcClientService: BlueprintGrpcClientService = bluePrintGrpcLibPropertyService
.blueprintGrpcClientService(grpcProperties)
return grpcClientService.channel()
}
selector
}
else -> {
- throw BluePrintException("couldn't process selector($selector)")
+ throw BlueprintException("couldn't process selector($selector)")
}
}
}
package org.onap.ccsdk.cds.blueprintsprocessor.services.execution.scripts
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintFunctionNode
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
import org.springframework.stereotype.Service
// TODO("After Jython depreciation, this interface will be removed")
@Deprecated("CDS won's support Jython services")
interface BlueprintJythonService {
- fun jythonComponentInstance(bluePrintContext: BluePrintContext, scriptClassReference: String):
+ fun jythonComponentInstance(bluePrintContext: BlueprintContext, scriptClassReference: String):
BlueprintFunctionNode<*, *>
}
@Service
open class DeprecatedBlueprintJythonService : BlueprintJythonService {
- override fun jythonComponentInstance(bluePrintContext: BluePrintContext, scriptClassReference: String):
+ override fun jythonComponentInstance(bluePrintContext: BlueprintContext, scriptClassReference: String):
BlueprintFunctionNode<*, *> {
- throw BluePrintProcessorException("Include python-executor module for Jython support")
+ throw BlueprintProcessorException("Include python-executor module for Jython support")
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.createExecutionServiceOutputProto
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.createStatus
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.toProto
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.jsonAsJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
import kotlin.test.assertNotNull
@Test
fun testNodeComponentRemoteScriptExecutorType() {
- val nodeType = BluePrintTypes.nodeTypeComponentRemoteScriptExecutor()
+ val nodeType = BlueprintTypes.nodeTypeComponentRemoteScriptExecutor()
assertNotNull(nodeType, "failed to generate nodeType Component Remote Script Executor")
}
fun testComponentRemoteScriptExecutor() {
runBlocking {
/** Mock blueprint context */
- val blueprintContext = mockk<BluePrintContext>()
+ val blueprintContext = mockk<BlueprintContext>()
every { blueprintContext.rootPath } returns normalizedPathName("target")
every {
blueprintContext.nodeTemplateOperationImplementation(
)
} returns Implementation()
- val bluePrintRuntime = mockk<DefaultBluePrintRuntimeService>("1234")
+ val bluePrintRuntime = mockk<DefaultBlueprintRuntimeService>("1234")
every { bluePrintRuntime.bluePrintContext() } returns blueprintContext
val mockExecutionServiceInput = mockExecutionServiceInput(bluePrintRuntime)
}
}
- private fun mockExecutionServiceInput(bluePrintRuntime: DefaultBluePrintRuntimeService): ExecutionServiceInput {
+ private fun mockExecutionServiceInput(bluePrintRuntime: DefaultBlueprintRuntimeService): ExecutionServiceInput {
val mapper = ObjectMapper()
val requestNode = mapper.createObjectNode()
requestNode.put("type", "grpc")
val operationInputs = hashMapOf<String, JsonNode>()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "remote-execute".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_INTERFACE] =
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = "remote-execute".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_INTERFACE] =
"ComponentRemoteScriptExecutor".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_OPERATION] = "process".asJsonPrimitive()
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_OPERATION] = "process".asJsonPrimitive()
operationInputs[ComponentRemoteScriptExecutor.INPUT_SELECTOR] = "remote-script-executor".asJsonPrimitive()
operationInputs[ComponentRemoteScriptExecutor.INPUT_BLUEPRINT_NAME] = "sample-blueprint".asJsonPrimitive()
return createExecutionServiceOutputProto(
executionServiceInput.commonHeader.toProto(),
executionServiceInput.actionIdentifiers.toProto(),
- createStatus(BluePrintConstants.STATUS_SUCCESS, 200),
+ createStatus(BlueprintConstants.STATUS_SUCCESS, 200),
responsePayload
)
}
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status
import org.onap.ccsdk.cds.controllerblueprints.core.MDCContext
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
+import org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
-private val log = logger(MockBluePrintProcessingServer::class)
+private val log = logger(MockBlueprintProcessingServer::class)
-class MockBluePrintProcessingServer : BluePrintProcessingServiceGrpc.BluePrintProcessingServiceImplBase() {
+class MockBlueprintProcessingServer : BlueprintProcessingServiceGrpc.BlueprintProcessingServiceImplBase() {
override fun process(responseObserver: StreamObserver<ExecutionServiceOutput>): StreamObserver<ExecutionServiceInput> {
val server = ServerBuilder
.forPort(50052)
.intercept(GrpcServerLoggingInterceptor())
- .addService(MockBluePrintProcessingServer())
+ .addService(MockBlueprintProcessingServer())
.build()
server.start()
log.info("GRPC Serve started(${server.isShutdown}) on port(${server.port})...")
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ACTION_MODE_SYNC
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.GRPCLibConstants
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.TokenAuthGrpcClientProperties
-import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BluePrintGrpcLibPropertyService
-import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.scripts.MockBluePrintProcessingServer
+import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.BlueprintGrpcLibPropertyService
+import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.scripts.MockBlueprintProcessingServer
import org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
@ExperimentalCoroutinesApi
@FlowPreview
fun testStreamingChannel() {
- grpcCleanup.register(serverBuilder.addService(MockBluePrintProcessingServer()).build().start())
+ grpcCleanup.register(serverBuilder.addService(MockBlueprintProcessingServer()).build().start())
val channel = grpcCleanup.register(channelBuilder.maxInboundMessageSize(1024).build())
runBlocking {
- val bluePrintGrpcLibPropertyService = BluePrintGrpcLibPropertyService(mockk())
+ val bluePrintGrpcLibPropertyService = BlueprintGrpcLibPropertyService(mockk())
val streamingRemoteExecutionService = StreamingRemoteExecutionServiceImpl(bluePrintGrpcLibPropertyService)
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.CommonHeader
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.CDS_LOCK_GROUP
import org.onap.ccsdk.cds.blueprintsprocessor.core.service.ClusterLock
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.nodeTypeComponentScriptExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
import org.onap.ccsdk.cds.controllerblueprints.core.data.LockAssignment
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintScriptsServiceImpl
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BlueprintScriptsServiceImpl
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
@ContextConfiguration(
classes = [
ComponentFunctionScriptingService::class,
- BluePrintScriptsServiceImpl::class, DeprecatedBlueprintJythonService::class
+ BlueprintScriptsServiceImpl::class, DeprecatedBlueprintJythonService::class
]
)
class AbstractComponentFunctionTest {
- lateinit var bluePrintRuntimeService: DefaultBluePrintRuntimeService
- lateinit var blueprintContext: BluePrintContext
- lateinit var blueprintClusterService: BluePrintClusterService
+ lateinit var bluePrintRuntimeService: DefaultBlueprintRuntimeService
+ lateinit var blueprintContext: BlueprintContext
+ lateinit var blueprintClusterService: BlueprintClusterService
@Autowired
lateinit var compSvc: ComponentFunctionScriptingService
@Test
fun testComponentScriptExecutorNodeType() {
- val componentScriptExecutor = BluePrintTypes.nodeTypeComponentScriptExecutor()
+ val componentScriptExecutor = BlueprintTypes.nodeTypeComponentScriptExecutor()
assertNotNull(componentScriptExecutor.interfaces, "failed to get interface operations")
}
/**
* Mocked input for abstract function test.
*/
- private fun getMockedInput(bluePrintRuntime: DefaultBluePrintRuntimeService):
+ private fun getMockedInput(bluePrintRuntime: DefaultBlueprintRuntimeService):
ExecutionServiceInput {
val mapper = ObjectMapper()
rootNode.put("type", "rest")
val operationInputs = hashMapOf<String, JsonNode>()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] =
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] =
"activate-restconf".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_INTERFACE] =
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_INTERFACE] =
"interfaceName".asJsonPrimitive()
- operationInputs[BluePrintConstants.PROPERTY_CURRENT_OPERATION] =
+ operationInputs[BlueprintConstants.PROPERTY_CURRENT_OPERATION] =
"operationName".asJsonPrimitive()
operationInputs["dynamic-properties"] = rootNode
package org.onap.ccsdk.cds.blueprintsprocessor.services.workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.sli.core.sli.SvcLogicContext
class BlueprintSvcLogicContext : SvcLogicContext() {
- private var bluePrintRuntimeService: BluePrintRuntimeService<*>? = null
+ private var bluePrintRuntimeService: BlueprintRuntimeService<*>? = null
private var request: Any? = null
private var response: Any? = null
- fun getBluePrintService(): BluePrintRuntimeService<*> {
+ fun getBlueprintService(): BlueprintRuntimeService<*> {
return this.bluePrintRuntimeService!!
}
- fun setBluePrintRuntimeService(bluePrintRuntimeService: BluePrintRuntimeService<*>) {
+ fun setBlueprintRuntimeService(bluePrintRuntimeService: BlueprintRuntimeService<*>) {
this.bluePrintRuntimeService = bluePrintRuntimeService
}
package org.onap.ccsdk.cds.blueprintsprocessor.services.workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.sli.core.sli.ExitNodeException
import org.onap.ccsdk.sli.core.sli.SvcLogicContext
import org.onap.ccsdk.sli.core.sli.SvcLogicException
fun unRegisterExecutors(name: String)
- suspend fun execute(graph: SvcLogicGraph, bluePrintRuntimeService: BluePrintRuntimeService<*>, input: Any): Any
+ suspend fun execute(graph: SvcLogicGraph, bluePrintRuntimeService: BlueprintRuntimeService<*>, input: Any): Any
override fun execute(module: String, rpc: String, version: String, mode: String, ctx: SvcLogicContext): SvcLogicContext {
TODO("not implemented")
override suspend fun execute(
graph: SvcLogicGraph,
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
input: Any
): Any {
// Initialise BlueprintSvcLogic Context with Blueprint Runtime Service and Input Request
val blueprintSvcLogicContext = BlueprintSvcLogicContext()
- blueprintSvcLogicContext.setBluePrintRuntimeService(bluePrintRuntimeService)
+ blueprintSvcLogicContext.setBlueprintRuntimeService(bluePrintRuntimeService)
blueprintSvcLogicContext.setRequest(input)
// Execute the Graph
execute(graph, blueprintSvcLogicContext)
import com.fasterxml.jackson.databind.JsonNode
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asObjectNode
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowExecutionService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowExecutionService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
@Service("bluePrintWorkflowExecutionService")
-open class BluePrintWorkflowExecutionServiceImpl(
+open class BlueprintWorkflowExecutionServiceImpl(
private val componentWorkflowExecutionService: ComponentWorkflowExecutionService,
private val dgWorkflowExecutionService: DGWorkflowExecutionService,
private val imperativeWorkflowExecutionService: ImperativeWorkflowExecutionService
-) : BluePrintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
+) : BlueprintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
- private val log = LoggerFactory.getLogger(BluePrintWorkflowExecutionServiceImpl::class.java)!!
+ private val log = LoggerFactory.getLogger(BlueprintWorkflowExecutionServiceImpl::class.java)!!
- override suspend fun executeBluePrintWorkflow(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ override suspend fun executeBlueprintWorkflow(
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
executionServiceInput: ExecutionServiceInput,
properties: MutableMap<String, Any>
): ExecutionServiceOutput {
// Assign Workflow inputs
// check if request structure exists
if (!executionServiceInput.payload.has("$workflowName-request")) {
- throw BluePrintProcessorException("Input request missing the expected '$workflowName-request' block!")
+ throw BlueprintProcessorException("Input request missing the expected '$workflowName-request' block!")
}
val input = executionServiceInput.payload.get("$workflowName-request")
bluePrintRuntimeService.assignWorkflowInputs(workflowName, input)
val workflow = bluePrintContext.workflowByName(workflowName)
- val steps = workflow.steps ?: throw BluePrintProcessorException("could't get steps for workflow($workflowName)")
+ val steps = workflow.steps ?: throw BlueprintProcessorException("could't get steps for workflow($workflowName)")
/** If workflow has multiple steps, then it is imperative workflow */
val executionServiceOutput: ExecutionServiceOutput = if (steps.size > 1) {
imperativeWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, properties)
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, properties)
} else {
// Get the DG Node Template
val nodeTemplateName = bluePrintContext.workflowFirstStepNodeTemplate(workflowName)
log.info("Executing workflow($workflowName) NodeTemplate($nodeTemplateName), derived from($derivedFrom)")
/** Return ExecutionServiceOutput based on DG node or Component Node */
when {
- derivedFrom.startsWith(BluePrintConstants.MODEL_TYPE_NODE_COMPONENT, true) -> {
+ derivedFrom.startsWith(BlueprintConstants.MODEL_TYPE_NODE_COMPONENT, true) -> {
componentWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, properties)
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, properties)
}
- derivedFrom.startsWith(BluePrintConstants.MODEL_TYPE_NODE_WORKFLOW, true) -> {
+ derivedFrom.startsWith(BlueprintConstants.MODEL_TYPE_NODE_WORKFLOW, true) -> {
dgWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, properties)
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, properties)
}
else -> {
- throw BluePrintProcessorException(
+ throw BlueprintProcessorException(
"couldn't execute workflow($workflowName) step mapped " +
"to node template($nodeTemplateName) derived from($derivedFrom)"
)
workflowOutputs = bluePrintRuntimeService.resolveWorkflowOutputs(workflowName)
} catch (e: RuntimeException) {
log.error("Failed to resolve outputs for workflow: $workflowName", e)
- e.message?.let { bluePrintRuntimeService.getBluePrintError().errors.add(it) }
+ e.message?.let { bluePrintRuntimeService.getBlueprintError().errors.add(it) }
}
// Set the Response Payload
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowExecutionService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowExecutionService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.springframework.stereotype.Service
@Service("componentWorkflowExecutionService")
open class ComponentWorkflowExecutionService(private val nodeTemplateExecutionService: NodeTemplateExecutionService) :
- BluePrintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
+ BlueprintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
- override suspend fun executeBluePrintWorkflow(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ override suspend fun executeBlueprintWorkflow(
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
executionServiceInput: ExecutionServiceInput,
properties: MutableMap<String, Any>
): ExecutionServiceOutput {
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.utils.SvcGraphUtils
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowExecutionService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowExecutionService
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
@Service("dgWorkflowExecutionService")
open class DGWorkflowExecutionService(private val blueprintSvcLogicService: BlueprintSvcLogicService) :
- BluePrintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
+ BlueprintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
private val log = LoggerFactory.getLogger(DGWorkflowExecutionService::class.java)
- override suspend fun executeBluePrintWorkflow(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ override suspend fun executeBlueprintWorkflow(
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
executionServiceInput: ExecutionServiceInput,
properties: MutableMap<String, Any>
): ExecutionServiceOutput {
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.Status
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.MDCContext
import org.onap.ccsdk.cds.controllerblueprints.core.asGraph
import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
import org.onap.ccsdk.cds.controllerblueprints.core.data.EdgeLabel
import org.onap.ccsdk.cds.controllerblueprints.core.data.Graph
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowExecutionService
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowExecutionService
import org.onap.ccsdk.cds.controllerblueprints.core.logger
-import org.onap.ccsdk.cds.controllerblueprints.core.service.AbstractBluePrintWorkFlowService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.AbstractBlueprintWorkFlowService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.onap.ccsdk.cds.controllerblueprints.core.service.NodeExecuteMessage
import org.onap.ccsdk.cds.controllerblueprints.core.service.NodeSkipMessage
import org.onap.ccsdk.cds.controllerblueprints.core.service.WorkflowExecuteMessage
class ImperativeWorkflowExecutionService(
private val nodeTemplateExecutionService: NodeTemplateExecutionService
) :
- BluePrintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
+ BlueprintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput> {
- override suspend fun executeBluePrintWorkflow(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ override suspend fun executeBlueprintWorkflow(
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
executionServiceInput: ExecutionServiceInput,
properties: MutableMap<String, Any>
): ExecutionServiceOutput {
val graph = bluePrintContext.workflowByName(workflowName).asGraph()
return coroutineScope {
- ImperativeBluePrintWorkflowService(
+ ImperativeBlueprintWorkflowService(
nodeTemplateExecutionService,
this.coroutineContext[MDCContext]
)
}
}
-open class ImperativeBluePrintWorkflowService(private val nodeTemplateExecutionService: NodeTemplateExecutionService, private val mdcContext: CoroutineContext?) :
- AbstractBluePrintWorkFlowService<ExecutionServiceInput, ExecutionServiceOutput>() {
+open class ImperativeBlueprintWorkflowService(private val nodeTemplateExecutionService: NodeTemplateExecutionService, private val mdcContext: CoroutineContext?) :
+ AbstractBlueprintWorkFlowService<ExecutionServiceInput, ExecutionServiceOutput>() {
final override val coroutineContext: CoroutineContext
get() = mdcContext?.let { super.coroutineContext + it } ?: super.coroutineContext
- val log = logger(ImperativeBluePrintWorkflowService::class)
+ val log = logger(ImperativeBlueprintWorkflowService::class)
- lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+ lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
lateinit var executionServiceInput: ExecutionServiceInput
lateinit var workflowName: String
override suspend fun executeWorkflow(
graph: Graph,
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
input: ExecutionServiceInput
): ExecutionServiceOutput {
this.graph = graph
if (!workflowActor.isClosedForSend) {
workflowActor.send(startMessage)
} else {
- throw BluePrintProcessorException("workflow($workflowActor) actor is closed")
+ throw BlueprintProcessorException("workflow($workflowActor) actor is closed")
}
return output.await()
}
if (exceptions.isNotEmpty()) {
exceptions.forEach {
val errorMessage = it.message ?: ""
- bluePrintRuntimeService.getBluePrintError().addError(errorMessage)
+ bluePrintRuntimeService.getBlueprintError().addError(errorMessage)
log.error("workflow($workflowId) exception :", it)
}
- message = BluePrintConstants.STATUS_FAILURE
+ message = BlueprintConstants.STATUS_FAILURE
} else {
- message = BluePrintConstants.STATUS_SUCCESS
+ message = BlueprintConstants.STATUS_SUCCESS
}
eventType = EventType.EVENT_COMPONENT_EXECUTED.name
}
.executeNodeTemplate(bluePrintRuntimeService, nodeTemplateName, nodeInput)
return when (executionServiceOutput.status.message) {
- BluePrintConstants.STATUS_FAILURE -> EdgeLabel.FAILURE
+ BlueprintConstants.STATUS_FAILURE -> EdgeLabel.FAILURE
else -> EdgeLabel.SUCCESS
}
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.StepData
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
@Service
-open class NodeTemplateExecutionService(private val bluePrintClusterService: BluePrintClusterService) {
+open class NodeTemplateExecutionService(private val bluePrintClusterService: BlueprintClusterService) {
private val log = LoggerFactory.getLogger(NodeTemplateExecutionService::class.java)!!
suspend fun executeNodeTemplate(
- bluePrintRuntimeService: BluePrintRuntimeService<*>,
+ bluePrintRuntimeService: BlueprintRuntimeService<*>,
nodeTemplateName: String,
executionServiceInput: ExecutionServiceInput
): ExecutionServiceOutput {
)
// Get the Component Instance
- val plugin = Blue
PrintDependencyService.instance<AbstractComponentFunction>(componentName)
+ val plugin = Blue
printDependencyService.instance<AbstractComponentFunction>(componentName)
// Set the Blueprint Services
plugin.bluePrintRuntimeService = bluePrintRuntimeService
plugin.bluePrintClusterService = bluePrintClusterService
// Populate Step Meta Data
val stepInputs: MutableMap<String, JsonNode> = hashMapOf()
- stepInputs[BluePrintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = nodeTemplateName.asJsonPrimitive()
- stepInputs[BluePrintConstants.PROPERTY_CURRENT_INTERFACE] = interfaceName.asJsonPrimitive()
- stepInputs[BluePrintConstants.PROPERTY_CURRENT_OPERATION] = operationName.asJsonPrimitive()
+ stepInputs[BlueprintConstants.PROPERTY_CURRENT_NODE_TEMPLATE] = nodeTemplateName.asJsonPrimitive()
+ stepInputs[BlueprintConstants.PROPERTY_CURRENT_INTERFACE] = interfaceName.asJsonPrimitive()
+ stepInputs[BlueprintConstants.PROPERTY_CURRENT_OPERATION] = operationName.asJsonPrimitive()
val stepInputData = StepData().apply {
name = nodeTemplateName
properties = stepInputs
try { // Get the Request from the Context and Set to the Function Input and Invoke the function
val executionOutput = nodeTemplateExecutionService.executeNodeTemplate(
- ctx.getBluePrintService(),
+ ctx.getBlueprintService(),
nodeTemplateName, executionInput
)
import org.junit.Test
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.executor.ComponentExecuteNodeExecutor
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.mock.PrototypeComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.mock.SingletonComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonReactorUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.MockBean
lateinit var dgWorkflowExecutionService: DGWorkflowExecutionService
@MockBean
- lateinit var bluePrintClusterService: BluePrintClusterService
+ lateinit var bluePrintClusterService: BlueprintClusterService
@Before
fun init() {
- BluePrintDependencyService.inject(applicationContext)
+ BlueprintDependencyService.inject(applicationContext)
}
@Test
fun testExecuteGraphWithSingleComponent() {
runBlocking {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
bluePrintRuntimeService.assignWorkflowInputs("resource-assignment", input)
val executionServiceOutput = dgWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, mutableMapOf())
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, mutableMapOf())
assertNotNull(executionServiceOutput, "failed to get response")
assertEquals(
- BluePrintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
+ BlueprintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
"failed to get successful response"
)
}
@Test
fun testExecuteGraphWithMultipleComponents() {
runBlocking {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
bluePrintRuntimeService.assignWorkflowInputs("assign-activate", input)
val executionServiceOutput = dgWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, mutableMapOf())
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, mutableMapOf())
assertNotNull(executionServiceOutput, "failed to get response")
assertEquals(
- BluePrintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
+ BlueprintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
"failed to get successful response"
)
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.CommonHeader
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceOutput
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.mock.MockComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintError
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintError
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.Step
import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
-import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintWorkflowExecutionService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintWorkflowExecutionService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.MockBean
@RunWith(SpringRunner::class)
@ContextConfiguration(classes = [WorkflowServiceConfiguration::class])
-class BluePrintWorkflowExecutionServiceImplTest {
+class BlueprintWorkflowExecutionServiceImplTest {
@Autowired
- lateinit var bluePrintWorkflowExecutionService: BluePrintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput>
+ lateinit var bluePrintWorkflowExecutionService: BlueprintWorkflowExecutionService<ExecutionServiceInput, ExecutionServiceOutput>
@MockBean
- lateinit var bluePrintClusterService: BluePrintClusterService
+ lateinit var bluePrintClusterService: BlueprintClusterService
@Before
fun init() {
- mockkObject(BluePrintDependencyService)
- every { BluePrintDependencyService.applicationContext.getBean(any()) } returns MockComponentFunction()
+ mockkObject(BlueprintDependencyService)
+ every { BlueprintDependencyService.applicationContext.getBean(any()) } returns MockComponentFunction()
}
@After
}
@Test
- fun testBluePrintWorkflowExecutionService() {
+ fun testBlueprintWorkflowExecutionService() {
runBlocking {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
)!!
val executionServiceOutput = bluePrintWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
assertNotNull(executionServiceOutput, "failed to get response")
assertEquals(
- BluePrintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
+ BlueprintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
"failed to get successful response"
)
}
}
@Test
- fun testImperativeBluePrintWorkflowExecutionService() {
+ fun testImperativeBlueprintWorkflowExecutionService() {
runBlocking {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
)!!
val executionServiceOutput = bluePrintWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
assertNotNull(executionServiceOutput, "failed to get response")
assertEquals(
- BluePrintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
+ BlueprintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
"failed to get successful response"
)
}
@Test
fun `Blueprint fails on missing workflowName-parameters with a useful message`() {
- assertFailsWith(exceptionClass = BluePrintProcessorException::class) {
+ assertFailsWith(exceptionClass = BlueprintProcessorException::class) {
runBlocking {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
)!!
val executionServiceOutput = bluePrintWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
}
}
}
@Test
fun `Should handle errors from resolve workflow output`() {
val imperativeWorkflowExecutionService: ImperativeWorkflowExecutionService = mockk()
- val bluePrintWorkflowExecutionServiceImpl = BluePrintWorkflowExecutionServiceImpl(
+ val bluePrintWorkflowExecutionServiceImpl = BlueprintWorkflowExecutionServiceImpl(
mockk(), mockk(), imperativeWorkflowExecutionService
)
- val bluePrintRuntimeService: BluePrintRuntimeService<MutableMap<String, JsonNode>> = mockk()
- val bluePrintContext: BluePrintContext = mockk()
+ val bluePrintRuntimeService: BlueprintRuntimeService<MutableMap<String, JsonNode>> = mockk()
+ val bluePrintContext: BlueprintContext = mockk()
val executionServiceInput = ExecutionServiceInput().apply {
this.actionIdentifiers = ActionIdentifiers().apply { this.actionName = "config-assign" }
this.commonHeader = CommonHeader()
val workflow = Workflow().apply {
this.steps = mutableMapOf("one" to Step(), "two" to Step())
}
- val blueprintError = BluePrintError()
+ val blueprintError = BlueprintError()
every { bluePrintRuntimeService.bluePrintContext() } returns bluePrintContext
every { bluePrintRuntimeService.assignWorkflowInputs(any(), any()) } returns Unit
} throws RuntimeException("failed to resolve property...")
every {
runBlocking {
- imperativeWorkflowExecutionService.executeBluePrintWorkflow(any(), any(), any())
+ imperativeWorkflowExecutionService.executeBlueprintWorkflow(any(), any(), any())
}
} returns ExecutionServiceOutput()
- every { bluePrintRuntimeService.getBluePrintError() } returns blueprintError
+ every { bluePrintRuntimeService.getBlueprintError() } returns blueprintError
runBlocking {
- val output = bluePrintWorkflowExecutionServiceImpl.executeBluePrintWorkflow(
+ val output = bluePrintWorkflowExecutionServiceImpl.executeBlueprintWorkflow(
bluePrintRuntimeService, executionServiceInput, mutableMapOf()
)
assertEquals("failed to resolve property...", blueprintError.errors[0])
import org.junit.Test
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.executor.ComponentExecuteNodeExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonReactorUtils
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.MockBean
lateinit var dgWorkflowExecutionService: DGWorkflowExecutionService
@MockBean
- lateinit var bluePrintClusterService: BluePrintClusterService
+ lateinit var bluePrintClusterService: BlueprintClusterService
@Before
fun init() {
- BluePrintDependencyService.inject(applicationContext)
+ BlueprintDependencyService.inject(applicationContext)
}
@Test
fun testExecuteDirectedGraph() {
runBlocking {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
val input = executionServiceInput.payload.get("resource-assignment-request")
bluePrintRuntimeService.assignWorkflowInputs("resource-assignment", input)
- val executionServiceOutput = dgWorkflowExecutionService.executeBluePrintWorkflow(
+ val executionServiceOutput = dgWorkflowExecutionService.executeBlueprintWorkflow(
bluePrintRuntimeService,
executionServiceInput, mutableMapOf()
)
assertNotNull(executionServiceOutput, "failed to get response")
assertEquals(
- BluePrintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
+ BlueprintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
"failed to get successful response"
)
}
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.mock.MockComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.mock.mockNodeTemplateComponentScriptExecutor
import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.dsl.serviceTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.logger
import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import kotlin.test.Test
import kotlin.test.assertEquals
@Before
fun init() {
- mockkObject(BluePrintDependencyService)
- every { BluePrintDependencyService.applicationContext.getBean(any()) } returns MockComponentFunction()
+ mockkObject(BlueprintDependencyService)
+ every { BlueprintDependencyService.applicationContext.getBean(any()) } returns MockComponentFunction()
}
@After
step("activate-licence", "activate-licence", "")
}
}
- nodeType(BluePrintTypes.nodeTypeComponentScriptExecutor())
+ nodeType(BlueprintTypes.nodeTypeComponentScriptExecutor())
}
}
fun testImperativeExecutionService() {
runBlocking {
val serviceTemplate = mockServiceTemplate()
- val bluePrintContext = BluePrintContext(serviceTemplate)
+ val bluePrintContext = BlueprintContext(serviceTemplate)
bluePrintContext.rootPath = normalizedPathName(".")
bluePrintContext.entryDefinition = "cba.imperative.test.ImperativeTestDefinitions.kt"
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime("12345", bluePrintContext)
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime("12345", bluePrintContext)
val executionServiceInput = JacksonUtils
.readValueFromClassPathFile(
val imperativeWorkflowExecutionService = ImperativeWorkflowExecutionService(NodeTemplateExecutionService(mockk()))
val output = imperativeWorkflowExecutionService
- .executeBluePrintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
+ .executeBlueprintWorkflow(bluePrintRuntimeService, executionServiceInput, hashMapOf())
assertNotNull(output, "failed to get imperative workflow output")
assertNotNull(output.status, "failed to get imperative workflow output status")
- assertEquals(output.status.message, BluePrintConstants.STATUS_SUCCESS)
+ assertEquals(output.status.message, BlueprintConstants.STATUS_SUCCESS)
assertEquals(output.status.eventType, EventType.EVENT_COMPONENT_EXECUTED.name)
}
}
import org.junit.Test
import org.junit.runner.RunWith
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BluePrintClusterService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.service.BlueprintClusterService
import org.onap.ccsdk.cds.blueprintsprocessor.services.workflow.mock.MockComponentFunction
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
-import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintDependencyService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.test.context.ContextConfiguration
class NodeTemplateExecutionServiceTest {
@MockBean
- lateinit var bluePrintClusterService: BluePrintClusterService
+ lateinit var bluePrintClusterService: BlueprintClusterService
@Before
fun init() {
- mockkObject(BluePrintDependencyService)
- every { BluePrintDependencyService.applicationContext.getBean(any()) } returns MockComponentFunction()
+ mockkObject(BlueprintDependencyService)
+ every { BlueprintDependencyService.applicationContext.getBean(any()) } returns MockComponentFunction()
}
@After
@Test
fun testExecuteNodeTemplate() {
runBlocking {
- val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime(
+ val bluePrintRuntimeService = BlueprintMetadataUtils.getBlueprintRuntime(
"1234",
"./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
)
assertNotNull(executionServiceOutput, "failed to get response")
assertEquals(
- BluePrintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
+ BlueprintConstants.STATUS_SUCCESS, executionServiceOutput.status.message,
"failed to get successful response"
)
}
import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.nodeTemplateComponentScriptExecutor
-import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.config.ConfigurableBeanFactory
import org.springframework.context.annotation.Scope
import org.springframework.stereotype.Component
-fun mockNodeTemplateComponentScriptExecutor(id: String, script: String) = BluePrintTypes.nodeTemplateComponentScriptExecutor(
+fun mockNodeTemplateComponentScriptExecutor(id: String, script: String) = BlueprintTypes.nodeTemplateComponentScriptExecutor(
id,
"mock($id) component function"
) {
# See the License for the specific language governing permissions and
# limitations under the License.
-from proto.BluePrintCommon_pb2 import *
-from proto.BluePrintProcessing_pb2 import *
+from proto.BlueprintCommon_pb2 import *
+from proto.BlueprintProcessing_pb2 import *
from .script_executor_configuration import *
from .executor_utils import *
from .blueprint_processing_server import *
\ No newline at end of file
import logging
from google.protobuf.json_format import MessageToJson
-from proto import BluePrintProcessing_pb2_grpc as BluePrintProcessing_pb2_grpc
+from proto import BlueprintProcessing_pb2_grpc as BlueprintProcessing_pb2_grpc
from .script_executor_configuration import ScriptExecutorConfiguration
from .executor_utils import instance_for_input
pass
-class BluePrintProcessingServer(BluePrintProcessing_pb2_grpc.BluePrintProcessingServiceServicer):
+class BlueprintProcessingServer(BlueprintProcessing_pb2_grpc.BlueprintProcessingServiceServicer):
def __init__(self, configuration: ScriptExecutorConfiguration):
self.logger = logging.getLogger(self.__class__.__name__)
from google.protobuf import json_format, struct_pb2
from google.protobuf.timestamp_pb2 import Timestamp
-from proto.BluePrintCommon_pb2 import (
+from proto.BlueprintCommon_pb2 import (
EVENT_COMPONENT_EXECUTED,
EVENT_COMPONENT_NOTIFICATION,
EVENT_COMPONENT_PROCESSING,
EVENT_COMPONENT_TRACE,
Status
)
-from proto.BluePrintProcessing_pb2 import (
+from proto.BlueprintProcessing_pb2 import (
ExecutionServiceInput,
ExecutionServiceOutput,
)
# limitations under the License.
import grpc
-from proto.BluePrintCommon_pb2 import ActionIdentifiers, CommonHeader
-from proto.BluePrintProcessing_pb2 import ExecutionServiceInput
-from proto.BluePrintProcessing_pb2_grpc import BluePrintProcessingServiceStub
+from proto.BlueprintCommon_pb2 import ActionIdentifiers, CommonHeader
+from proto.BlueprintProcessing_pb2 import ExecutionServiceInput
+from proto.BlueprintProcessing_pb2_grpc import BlueprintProcessingServiceStub
def generate_messages():
with open('py-executor-chain.pem', 'rb') as f:
creds = grpc.ssl_channel_credentials(f.read())
channel = grpc.secure_channel('localhost:50052', creds)
- stub = BluePrintProcessingServiceStub(channel)
+ stub = BlueprintProcessingServiceStub(channel)
messages = generate_messages()
responses = stub.process(messages)
### Insecure channel
```
-from proto.BluePrintCommon_pb2_grpc import ActionIdentifiers, CommonHeader
-from proto.BluePrintProcessing_pb2_grpc import ExecutionServiceInput
+from proto.BlueprintCommon_pb2_grpc import ActionIdentifiers, CommonHeader
+from proto.BlueprintProcessing_pb2_grpc import ExecutionServiceInput
from resource_resolution.grpc.client import Client as ResourceResolutionClient
### Secure channel
```
-from proto.BluePrintCommon_pb2_grpc import ActionIdentifiers, CommonHeader
-from proto.BluePrintProcessing_pb2_grpc import ExecutionServiceInput
+from proto.BlueprintCommon_pb2_grpc import ActionIdentifiers, CommonHeader
+from proto.BlueprintProcessing_pb2_grpc import ExecutionServiceInput
from resource_resolution.grpc.client import Client as ResourceResolutionClient
### Authorizarion header
```
-from proto.BluePrintCommon_pb2 import ActionIdentifiers, CommonHeader
-from proto.BluePrintProcessing_pb2 import ExecutionServiceInput
+from proto.BlueprintCommon_pb2 import ActionIdentifiers, CommonHeader
+from proto.BlueprintProcessing_pb2 import ExecutionServiceInput
from resource_resolution.grpc.client import Client as ResourceResolutionClient
secure_channel,
ssl_channel_credentials,
)
-from proto.BluePrintProcessing_pb2 import ExecutionServiceInput, ExecutionServiceOutput
-from proto.BluePrintProcessing_pb2_grpc import BluePrintProcessingServiceStub
+from proto.BlueprintProcessing_pb2 import ExecutionServiceInput, ExecutionServiceOutput
+from proto.BlueprintProcessing_pb2_grpc import BlueprintProcessingServiceStub
from .authorization import AuthTokenInterceptor
self.logger.debug(f"Create insecure channel to connect to {server_address}")
if use_header_auth:
self.channel: Channel = intercept_channel(self.channel, AuthTokenInterceptor(header_auth_token))
- self.stub: BluePrintProcessingServiceStub = BluePrintProcessingServiceStub(self.channel)
+ self.stub: BlueprintProcessingServiceStub = BlueprintProcessingServiceStub(self.channel)
def close(self) -> None:
"""Close client session.
from google.protobuf import json_format
-from proto.BluePrintProcessing_pb2 import ExecutionServiceInput, ExecutionServiceOutput
+from proto.BlueprintProcessing_pb2 import ExecutionServiceInput, ExecutionServiceOutput
from .grpc import Client as GrpcClient
from .http import Client as HttpClient
It's possible to store/retrieve templates using pair of artifact name and resolution key OR
resource type and resource id. This method checks if valid combination of parameters were used.
-
+
Args:
resolution_key (str, optional): resolutionKey HTTP request parameter value. Defaults to None.
resource_type (str, optional): resourceType HTTP request parameter value. Defaults to None.
resource_id (str, optional): resourceId HTTP request parameter value. Defaults to None.
-
+
Raises:
AttributeError: Invalid combination of parametes used
"""
import grpc
from manager.servicer import ArtifactManagerServicer
-from proto.BluePrintManagement_pb2_grpc import add_BluePrintManagementServiceServicer_to_server
+from proto.BlueprintManagement_pb2_grpc import add_BlueprintManagementServiceServicer_to_server
-from blueprints_grpc import BluePrintProcessing_pb2_grpc, ScriptExecutorConfiguration
-from blueprints_grpc.blueprint_processing_server import BluePrintProcessingServer
+from blueprints_grpc import BlueprintProcessing_pb2_grpc, ScriptExecutorConfiguration
+from blueprints_grpc.blueprint_processing_server import BlueprintProcessingServer
from blueprints_grpc.request_header_validator_interceptor import RequestHeaderValidatorInterceptor
logger = logging.getLogger("Server")
# create server
server = grpc.server(futures.ThreadPoolExecutor(max_workers=int(maxWorkers)))
- BluePrintProcessing_pb2_grpc.add_BluePrintProcessingServiceServicer_to_server(
- BluePrintProcessingServer(configuration), server
+ BlueprintProcessing_pb2_grpc.add_BlueprintProcessingServiceServicer_to_server(
+ BlueprintProcessingServer(configuration), server
)
- add_BluePrintManagementServiceServicer_to_server(ArtifactManagerServicer(), server)
+ add_BlueprintManagementServiceServicer_to_server(ArtifactManagerServicer(), server)
# add secure port using credentials
server.add_secure_port('[::]:' + port, server_credentials)
# create server with token authentication interceptors
server = grpc.server(futures.ThreadPoolExecutor(max_workers=int(maxWorkers)),
interceptors=(header_validator,))
- BluePrintProcessing_pb2_grpc.add_BluePrintProcessingServiceServicer_to_server(
- BluePrintProcessingServer(configuration), server
+ BlueprintProcessing_pb2_grpc.add_BlueprintProcessingServiceServicer_to_server(
+ BlueprintProcessingServer(configuration), server
)
- add_BluePrintManagementServiceServicer_to_server(ArtifactManagerServicer(), server)
+ add_BlueprintManagementServiceServicer_to_server(ArtifactManagerServicer(), server)
server.add_insecure_port('[::]:' + port)
server.start()
final String archivePath = cbaArchivePath.toString();
// Extract CBA archive from CSAR package and store it into local disk
- csarFiles.forEach(file -> listenerService.extractBluePrint(file.getAbsolutePath(), archivePath));
+ csarFiles.forEach(file -> listenerService.extractBlueprint(file.getAbsolutePath(), archivePath));
csarFiles.forEach(file -> FileUtil.deleteFile(file, csarArchivePath.toString()));
} else {
LOGGER.error("Could not able to read CSAR files from this location {}", csarArchivePath);
}
- listenerService.saveBluePrintToCdsDatabase(cbaArchivePath, sdcListenerDto.getManagedChannelForGrpc());
+ listenerService.saveBlueprintToCdsDatabase(cbaArchivePath, sdcListenerDto.getManagedChannelForGrpc());
}
}
import io.grpc.ManagedChannel;
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementServiceGrpc;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementServiceGrpc.BluePrintManagementServiceBlockingStub;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementServiceGrpc;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementServiceGrpc.BlueprintManagementServiceBlockingStub;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("listenerservice")
@Component
-public class BluePrintProcesssorHandler implements AutoCloseable {
+public class BlueprintProcesssorHandler implements AutoCloseable {
- private static final Logger LOGGER = LoggerFactory.getLogger(BluePrintProcesssorHandler.class);
+ private static final Logger LOGGER = LoggerFactory.getLogger(BlueprintProcesssorHandler.class);
private ManagedChannel channel;
/**
* Sending CBA archive to CDS backend to store into its Database.
*
- * @param request BluePrintManagementInput object holds CBA archive, its version and blueprints.
+ * @param request BlueprintManagementInput object holds CBA archive, its version and blueprints.
* @param managedChannel - ManagedChannel object helps to access the server or application end point.
*
* @return A response object
*/
- public Status sendRequest(BluePrintUploadInput request, ManagedChannel managedChannel) {
+ public Status sendRequest(BlueprintUploadInput request, ManagedChannel managedChannel) {
LOGGER.info("Sending request to blueprint processor");
this.channel = managedChannel;
- final BluePrintManagementServiceBlockingStub syncStub = BluePrintManagementServiceGrpc.newBlockingStub(channel);
+ final BlueprintManagementServiceBlockingStub syncStub = BlueprintManagementServiceGrpc.newBlockingStub(channel);
// Send the request to CDS backend.
- final BluePrintManagementOutput response = syncStub.uploadBlueprint(request);
+ final BlueprintManagementOutput response = syncStub.uploadBlueprint(request);
return response.getStatus();
}
* @param csarArchivePath The path where CSAR archive is stored.
* @param cbaArchivePath The destination path where CBA will be stored.
*/
- void extractBluePrint(String csarArchivePath, String cbaArchivePath);
+ void extractBlueprint(String csarArchivePath, String cbaArchivePath);
/**
* Store the Zip file into CDS database.
* @param path path where zip file exists.
* @param managedChannel To access the blueprint processor application end point
*/
- void saveBluePrintToCdsDatabase(Path path, ManagedChannel managedChannel);
+ void saveBlueprintToCdsDatabase(Path path, ManagedChannel managedChannel);
/**
* Extract and store the csar package to local disk.
import org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers;
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader;
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput;
import org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk;
import org.onap.ccsdk.cds.controllerblueprints.management.api.UploadAction;
import org.onap.ccsdk.cds.sdclistener.client.SdcListenerAuthClientInterceptor;
import org.onap.ccsdk.cds.sdclistener.dto.SdcListenerDto;
-import org.onap.ccsdk.cds.sdclistener.handler.BluePrintProcesssorHandler;
+import org.onap.ccsdk.cds.sdclistener.handler.BlueprintProcesssorHandler;
import org.onap.ccsdk.cds.sdclistener.status.SdcListenerStatus;
import org.onap.ccsdk.cds.sdclistener.util.FileUtil;
import org.onap.sdc.api.results.IDistributionClientDownloadResult;
public class ListenerServiceImpl implements ListenerService {
@Autowired
- private BluePrintProcesssorHandler bluePrintProcesssorHandler;
+ private BlueprintProcesssorHandler bluePrintProcesssorHandler;
@Autowired
private SdcListenerAuthClientInterceptor sdcListenerAuthClientInterceptor;
private static final Logger LOGGER = LoggerFactory.getLogger(ListenerServiceImpl.class);
@Override
- public void extractBluePrint(String csarArchivePath, String cbaArchivePath) {
+ public void extractBlueprint(String csarArchivePath, String cbaArchivePath) {
int validPathCount = 0;
final String distributionId = getDistributionId();
final String artifactUrl = getArtifactUrl();
validPathCount++;
final String cbaArchiveName = Paths.get(fileName).getFileName().toString();
LOGGER.info("Storing the CBA archive {}", cbaArchiveName);
- storeBluePrint(zipFile, cbaArchiveName, cbaStorageDir, entry);
+ storeBlueprint(zipFile, cbaArchiveName, cbaStorageDir, entry);
}
}
}
}
- private void storeBluePrint(ZipFile zipFile, String fileName, Path cbaArchivePath, ZipEntry entry) {
+ private void storeBlueprint(ZipFile zipFile, String fileName, Path cbaArchivePath, ZipEntry entry) {
Path targetLocation = cbaArchivePath.resolve(fileName);
LOGGER.info("The target location for zip file is {}", targetLocation);
File targetZipFile = new File(targetLocation.toString());
}
@Override
- public void saveBluePrintToCdsDatabase(Path cbaArchivePath, ManagedChannel channel) {
+ public void saveBlueprintToCdsDatabase(Path cbaArchivePath, ManagedChannel channel) {
List<File> zipFiles = FileUtil.getFilesFromDisk(cbaArchivePath);
if (!zipFiles.isEmpty()) {
prepareRequestForCdsBackend(zipFiles, channel, cbaArchivePath.toString());
files.forEach(zipFile -> {
try {
- final BluePrintUploadInput request = generateBluePrintUploadInputBuilder(zipFile, path);
+ final BlueprintUploadInput request = generateBlueprintUploadInputBuilder(zipFile, path);
// Send request to CDS Backend.
final Status responseStatus = bluePrintProcesssorHandler.sendRequest(request, managedChannel);
});
}
- private BluePrintUploadInput generateBluePrintUploadInputBuilder(File file, String path) throws IOException {
+ private BlueprintUploadInput generateBlueprintUploadInputBuilder(File file, String path) throws IOException {
byte[] bytes = FileUtils.readFileToByteArray(file);
FileChunk fileChunk = FileChunk.newBuilder().setChunk(ByteString.copyFrom(bytes)).build();
FileUtil.deleteFile(file, path);
- return BluePrintUploadInput.newBuilder()
+ return BlueprintUploadInput.newBuilder()
.setCommonHeader(CommonHeader.newBuilder().setRequestId(UUID.randomUUID().toString())
.setSubRequestId(UUID.randomUUID().toString()).setOriginatorId("SDC-LISTENER").build())
.setActionIdentifiers(
import org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers;
import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader;
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementServiceGrpc.BluePrintManagementServiceImplBase;
-import org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementServiceGrpc.BlueprintManagementServiceImplBase;
+import org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput;
import org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk;
import org.onap.ccsdk.cds.controllerblueprints.management.api.UploadAction;
import org.onap.ccsdk.cds.sdclistener.client.SdcListenerAuthClientInterceptor;
import static org.junit.Assert.assertTrue;
@RunWith(SpringRunner.class)
-@EnableConfigurationProperties({BluePrintProcesssorHandler.class, SdcListenerAuthClientInterceptor.class})
-@SpringBootTest(classes = {BluePrintProcessorHandlerTest.class})
-public class BluePrintProcessorHandlerTest {
+@EnableConfigurationProperties({BlueprintProcesssorHandler.class, SdcListenerAuthClientInterceptor.class})
+@SpringBootTest(classes = {BlueprintProcessorHandlerTest.class})
+public class BlueprintProcessorHandlerTest {
@Autowired
- private BluePrintProcesssorHandler bluePrintProcesssorHandler;
+ private BlueprintProcesssorHandler bluePrintProcesssorHandler;
@Autowired
private SdcListenerAuthClientInterceptor sdcListenerAuthClientInterceptor;
@Before
public void setUp() throws IOException {
- final BluePrintManagementServiceImplBase serviceImplBase = new BluePrintManagementServiceImplBase() {
+ final BlueprintManagementServiceImplBase serviceImplBase = new BlueprintManagementServiceImplBase() {
@Override
- public void uploadBlueprint(BluePrintUploadInput request,
- StreamObserver<BluePrintManagementOutput> responseObserver) {
- responseObserver.onNext(getBluePrintManagementOutput());
+ public void uploadBlueprint(BlueprintUploadInput request,
+ StreamObserver<BlueprintManagementOutput> responseObserver) {
+ responseObserver.onNext(getBlueprintManagementOutput());
responseObserver.onCompleted();
}
};
@Test
public void testApplicationEndPointSucess() throws IOException {
// Arrange
- BluePrintUploadInput request = generateRequest();
+ BlueprintUploadInput request = generateRequest();
// Act
Status output = bluePrintProcesssorHandler.sendRequest(request, channel);
assertTrue(output.getMessage().contains(SUCCESS_MSG));
}
- private BluePrintUploadInput generateRequest() throws IOException {
+ private BlueprintUploadInput generateRequest() throws IOException {
File file = Paths.get(CBA_ARCHIVE).toFile();
byte[] bytes = FileUtils.readFileToByteArray(file);
FileChunk fileChunk = FileChunk.newBuilder().setChunk(ByteString.copyFrom(bytes)).build();
- return BluePrintUploadInput.newBuilder()
+ return BlueprintUploadInput.newBuilder()
.setCommonHeader(CommonHeader.newBuilder().setRequestId(UUID.randomUUID().toString())
.setSubRequestId(UUID.randomUUID().toString()).setOriginatorId("SDC-LISTENER").build())
.setActionIdentifiers(
.setFileChunk(fileChunk).build();
}
- private BluePrintManagementOutput getBluePrintManagementOutput() {
- return BluePrintManagementOutput.newBuilder()
+ private BlueprintManagementOutput getBlueprintManagementOutput() {
+ return BlueprintManagementOutput.newBuilder()
.setStatus(Status.newBuilder().setMessage(SUCCESS_MSG).setCode(200).build()).build();
}
import org.onap.ccsdk.cds.sdclistener.SdcListenerConfiguration;
import org.onap.ccsdk.cds.sdclistener.client.SdcListenerAuthClientInterceptor;
import org.onap.ccsdk.cds.sdclistener.dto.SdcListenerDto;
-import org.onap.ccsdk.cds.sdclistener.handler.BluePrintProcesssorHandler;
+import org.onap.ccsdk.cds.sdclistener.handler.BlueprintProcesssorHandler;
import org.onap.ccsdk.cds.sdclistener.status.SdcListenerStatus;
import org.onap.sdc.api.results.IDistributionClientDownloadResult;
import org.onap.sdc.impl.mock.DistributionClientResultStubImpl;
import static org.onap.sdc.utils.DistributionStatusEnum.COMPONENT_DONE_OK;
@RunWith(SpringRunner.class)
-@EnableConfigurationProperties({SdcListenerAuthClientInterceptor.class, BluePrintProcesssorHandler.class,
+@EnableConfigurationProperties({SdcListenerAuthClientInterceptor.class, BlueprintProcesssorHandler.class,
SdcListenerDto.class, ListenerServiceImpl.class, SdcListenerStatus.class, SdcListenerConfiguration.class})
@SpringBootTest(classes = {ListenerServiceImplTest.class})
public class ListenerServiceImplTest {
}
@Test
- public void extractBluePrintSuccessfully() throws IOException {
+ public void extractBlueprintSuccessfully() throws IOException {
// Act
- listenerService.extractBluePrint(CSAR_SAMPLE, tempDirectoryPath.toString());
+ listenerService.extractBlueprint(CSAR_SAMPLE, tempDirectoryPath.toString());
// Verify.
String result = checkFileExists(tempDirectoryPath);
}
@Test
- public void extractBluePrintFailure() {
+ public void extractBlueprintFailure() {
// Arrange
Mockito.when(listenerDto.getDistributionId()).thenReturn(DISTRIBUTION_ID);
Mockito.when(listenerDto.getArtifactUrl()).thenReturn(URL);
SDC_LISTENER_COMPONENT);
// Act
- listenerService.extractBluePrint(WRONG_CSAR_SAMPLE, tempDirectoryPath.toString());
+ listenerService.extractBlueprint(WRONG_CSAR_SAMPLE, tempDirectoryPath.toString());
// Verify
Mockito.verify(status).sendResponseBackToSdc(DISTRIBUTION_ID, COMPONENT_DONE_OK, null, URL,
# limitations under the License.
# Generated by the protocol buffer compiler. DO NOT EDIT!
-# source: BluePrintCommon.proto
+# source: BlueprintCommon.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
DESCRIPTOR = _descriptor.FileDescriptor(
- name='BluePrintCommon.proto',
+ name='BlueprintCommon.proto',
package='org.onap.ccsdk.cds.controllerblueprints.common.api',
syntax='proto3',
serialized_options=_b('P\001'),
CommonHeader = _reflection.GeneratedProtocolMessageType('CommonHeader', (_message.Message,), {
'DESCRIPTOR' : _COMMONHEADER,
- '__module__' : 'BluePrintCommon_pb2'
+ '__module__' : 'BlueprintCommon_pb2'
# @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader)
})
_sym_db.RegisterMessage(CommonHeader)
Flag = _reflection.GeneratedProtocolMessageType('Flag', (_message.Message,), {
'DESCRIPTOR' : _FLAG,
- '__module__' : 'BluePrintCommon_pb2'
+ '__module__' : 'BlueprintCommon_pb2'
# @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.common.api.Flag)
})
_sym_db.RegisterMessage(Flag)
ActionIdentifiers = _reflection.GeneratedProtocolMessageType('ActionIdentifiers', (_message.Message,), {
'DESCRIPTOR' : _ACTIONIDENTIFIERS,
- '__module__' : 'BluePrintCommon_pb2'
+ '__module__' : 'BlueprintCommon_pb2'
# @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers)
})
_sym_db.RegisterMessage(ActionIdentifiers)
Status = _reflection.GeneratedProtocolMessageType('Status', (_message.Message,), {
'DESCRIPTOR' : _STATUS,
- '__module__' : 'BluePrintCommon_pb2'
+ '__module__' : 'BlueprintCommon_pb2'
# @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.common.api.Status)
})
_sym_db.RegisterMessage(Status)
# limitations under the License.
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
-# source: BluePrintManagement.proto
+# source: BlueprintManagement.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
-from proto import BluePrintCommon_pb2 as BluePrintCommon__pb2
+from proto import BlueprintCommon_pb2 as BlueprintCommon__pb2
DESCRIPTOR = _descriptor.FileDescriptor(
- name='BluePrintManagement.proto',
+ name='BlueprintManagement.proto',
package='org.onap.ccsdk.cds.controllerblueprints.management.api',
syntax='proto3',
serialized_options=_b('P\001'),
- serialized_pb=_b('\n\x19\x42luePrintManagement.proto\x12\x36org.onap.ccsdk.cds.controllerblueprints.management.api\x1a\x1cgoogle/protobuf/struct.proto\x1a\x15\x42luePrintCommon.proto\"\xd3\x02\n\x14\x42luePrintUploadInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12T\n\tfileChunk\x18\x02 \x01(\x0b\x32\x41.org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk\x12`\n\x11\x61\x63tionIdentifiers\x18\x03 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12+\n\nproperties\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xff\x01\n\x16\x42luePrintDownloadInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12`\n\x11\x61\x63tionIdentifiers\x18\x02 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12+\n\nproperties\x18\x03 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xfd\x01\n\x14\x42luePrintRemoveInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12`\n\x11\x61\x63tionIdentifiers\x18\x02 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12+\n\nproperties\x18\x03 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xb9\x01\n\x17\x42luePrintBootstrapInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12\x0f\n\x07loadCBA\x18\x02 \x01(\x08\x12\x15\n\rloadModelType\x18\x03 \x01(\x08\x12\x1e\n\x16loadResourceDictionary\x18\x04 \x01(\x08\"\xc2\x02\n\x19\x42luePrintManagementOutput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12T\n\tfileChunk\x18\x02 \x01(\x0b\x32\x41.org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk\x12J\n\x06status\x18\x03 \x01(\x0b\x32:.org.onap.ccsdk.cds.controllerblueprints.common.api.Status\x12+\n\nproperties\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"\x1a\n\tFileChunk\x12\r\n\x05\x63hunk\x18\x01 \x01(\x0c*4\n\x0e\x44ownloadAction\x12\n\n\x06SEARCH\x10\x00\x12\x0b\n\x07STARTER\x10\x01\x12\t\n\x05\x43LONE\x10\x02*@\n\x0cUploadAction\x12\t\n\x05\x44RAFT\x10\x00\x12\n\n\x06\x45NRICH\x10\x01\x12\x0c\n\x08VALIDATE\x10\x02\x12\x0b\n\x07PUBLISH\x10\x03*\x1b\n\x0cRemoveAction\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x32\xfa\x05\n\x1a\x42luePrintManagementService\x12\xb6\x01\n\x11\x64ownloadBlueprint\x12N.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput\x12\xb2\x01\n\x0fuploadBlueprint\x12L.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput\x12\xb2\x01\n\x0fremoveBlueprint\x12L.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput\x12\xb8\x01\n\x12\x62ootstrapBlueprint\x12O.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutputB\x02P\x01\x62\x06proto3')
+ serialized_pb=_b('\n\x19\x42luePrintManagement.proto\x12\x36org.onap.ccsdk.cds.controllerblueprints.management.api\x1a\x1cgoogle/protobuf/struct.proto\x1a\x15\x42luePrintCommon.proto\"\xd3\x02\n\x14\x42luePrintUploadInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12T\n\tfileChunk\x18\x02 \x01(\x0b\x32\x41.org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk\x12`\n\x11\x61\x63tionIdentifiers\x18\x03 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12+\n\nproperties\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xff\x01\n\x16\x42luePrintDownloadInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12`\n\x11\x61\x63tionIdentifiers\x18\x02 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12+\n\nproperties\x18\x03 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xfd\x01\n\x14\x42luePrintRemoveInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12`\n\x11\x61\x63tionIdentifiers\x18\x02 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12+\n\nproperties\x18\x03 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xb9\x01\n\x17\x42luePrintBootstrapInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12\x0f\n\x07loadCBA\x18\x02 \x01(\x08\x12\x15\n\rloadModelType\x18\x03 \x01(\x08\x12\x1e\n\x16loadResourceDictionary\x18\x04 \x01(\x08\"\xc2\x02\n\x19\x42luePrintManagementOutput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12T\n\tfileChunk\x18\x02 \x01(\x0b\x32\x41.org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk\x12J\n\x06status\x18\x03 \x01(\x0b\x32:.org.onap.ccsdk.cds.controllerblueprints.common.api.Status\x12+\n\nproperties\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct\"\x1a\n\tFileChunk\x12\r\n\x05\x63hunk\x18\x01 \x01(\x0c*4\n\x0e\x44ownloadAction\x12\n\n\x06SEARCH\x10\x00\x12\x0b\n\x07STARTER\x10\x01\x12\t\n\x05\x43LONE\x10\x02*@\n\x0cUploadAction\x12\t\n\x05\x44RAFT\x10\x00\x12\n\n\x06\x45NRICH\x10\x01\x12\x0c\n\x08VALIDATE\x10\x02\x12\x0b\n\x07PUBLISH\x10\x03*\x1b\n\x0cRemoveAction\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x32\xfa\x05\n\x1a\x42luePrintManagementService\x12\xb6\x01\n\x11\x64ownloadBlueprint\x12N.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput\x12\xb2\x01\n\x0fuploadBlueprint\x12L.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput\x12\xb2\x01\n\x0fremoveBlueprint\x12L.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput\x12\xb8\x01\n\x12\x62ootstrapBlueprint\x12O.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput\x1aQ.org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutputB\x02P\x01\x62\x06proto3')
,
- dependencies=[google_dot_protobuf_dot_struct__pb2.DESCRIPTOR,BluePrintCommon__pb2.DESCRIPTOR,])
+ dependencies=[google_dot_protobuf_dot_struct__pb2.DESCRIPTOR,BlueprintCommon__pb2.DESCRIPTOR,])
_DOWNLOADACTION = _descriptor.EnumDescriptor(
name='DownloadAction',
_BLUEPRINTUPLOADINPUT = _descriptor.Descriptor(
- name='BluePrintUploadInput',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput',
+ name='BlueprintUploadInput',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
- name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput.commonHeader', index=0,
+ name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput.commonHeader', index=0,
number=1, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='fileChunk', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput.fileChunk', index=1,
+ name='fileChunk', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput.fileChunk', index=1,
number=2, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='actionIdentifiers', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput.actionIdentifiers', index=2,
+ name='actionIdentifiers', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput.actionIdentifiers', index=2,
number=3, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput.properties', index=3,
+ name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput.properties', index=3,
number=4, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
_BLUEPRINTDOWNLOADINPUT = _descriptor.Descriptor(
- name='BluePrintDownloadInput',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput',
+ name='BlueprintDownloadInput',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
- name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput.commonHeader', index=0,
+ name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput.commonHeader', index=0,
number=1, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='actionIdentifiers', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput.actionIdentifiers', index=1,
+ name='actionIdentifiers', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput.actionIdentifiers', index=1,
number=2, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput.properties', index=2,
+ name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput.properties', index=2,
number=3, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
_BLUEPRINTREMOVEINPUT = _descriptor.Descriptor(
- name='BluePrintRemoveInput',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput',
+ name='BlueprintRemoveInput',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
- name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput.commonHeader', index=0,
+ name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput.commonHeader', index=0,
number=1, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='actionIdentifiers', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput.actionIdentifiers', index=1,
+ name='actionIdentifiers', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput.actionIdentifiers', index=1,
number=2, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput.properties', index=2,
+ name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput.properties', index=2,
number=3, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
_BLUEPRINTBOOTSTRAPINPUT = _descriptor.Descriptor(
- name='BluePrintBootstrapInput',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput',
+ name='BlueprintBootstrapInput',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
- name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput.commonHeader', index=0,
+ name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput.commonHeader', index=0,
number=1, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='loadCBA', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput.loadCBA', index=1,
+ name='loadCBA', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput.loadCBA', index=1,
number=2, type=8, cpp_type=7, label=1,
has_default_value=False, default_value=False,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='loadModelType', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput.loadModelType', index=2,
+ name='loadModelType', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput.loadModelType', index=2,
number=3, type=8, cpp_type=7, label=1,
has_default_value=False, default_value=False,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='loadResourceDictionary', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput.loadResourceDictionary', index=3,
+ name='loadResourceDictionary', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput.loadResourceDictionary', index=3,
number=4, type=8, cpp_type=7, label=1,
has_default_value=False, default_value=False,
message_type=None, enum_type=None, containing_type=None,
_BLUEPRINTMANAGEMENTOUTPUT = _descriptor.Descriptor(
- name='BluePrintManagementOutput',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput',
+ name='BlueprintManagementOutput',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput',
filename=None,
file=DESCRIPTOR,
containing_type=None,
fields=[
_descriptor.FieldDescriptor(
- name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput.commonHeader', index=0,
+ name='commonHeader', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput.commonHeader', index=0,
number=1, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='fileChunk', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput.fileChunk', index=1,
+ name='fileChunk', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput.fileChunk', index=1,
number=2, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='status', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput.status', index=2,
+ name='status', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput.status', index=2,
number=3, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
is_extension=False, extension_scope=None,
serialized_options=None, file=DESCRIPTOR),
_descriptor.FieldDescriptor(
- name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput.properties', index=3,
+ name='properties', full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput.properties', index=3,
number=4, type=11, cpp_type=10, label=1,
has_default_value=False, default_value=None,
message_type=None, enum_type=None, containing_type=None,
serialized_end=1533,
)
-_BLUEPRINTUPLOADINPUT.fields_by_name['commonHeader'].message_type = BluePrintCommon__pb2._COMMONHEADER
+_BLUEPRINTUPLOADINPUT.fields_by_name['commonHeader'].message_type = BlueprintCommon__pb2._COMMONHEADER
_BLUEPRINTUPLOADINPUT.fields_by_name['fileChunk'].message_type = _FILECHUNK
-_BLUEPRINTUPLOADINPUT.fields_by_name['actionIdentifiers'].message_type = BluePrintCommon__pb2._ACTIONIDENTIFIERS
+_BLUEPRINTUPLOADINPUT.fields_by_name['actionIdentifiers'].message_type = BlueprintCommon__pb2._ACTIONIDENTIFIERS
_BLUEPRINTUPLOADINPUT.fields_by_name['properties'].message_type = google_dot_protobuf_dot_struct__pb2._STRUCT
-_BLUEPRINTDOWNLOADINPUT.fields_by_name['commonHeader'].message_type = BluePrintCommon__pb2._COMMONHEADER
-_BLUEPRINTDOWNLOADINPUT.fields_by_name['actionIdentifiers'].message_type = BluePrintCommon__pb2._ACTIONIDENTIFIERS
+_BLUEPRINTDOWNLOADINPUT.fields_by_name['commonHeader'].message_type = BlueprintCommon__pb2._COMMONHEADER
+_BLUEPRINTDOWNLOADINPUT.fields_by_name['actionIdentifiers'].message_type = BlueprintCommon__pb2._ACTIONIDENTIFIERS
_BLUEPRINTDOWNLOADINPUT.fields_by_name['properties'].message_type = google_dot_protobuf_dot_struct__pb2._STRUCT
-_BLUEPRINTREMOVEINPUT.fields_by_name['commonHeader'].message_type = BluePrintCommon__pb2._COMMONHEADER
-_BLUEPRINTREMOVEINPUT.fields_by_name['actionIdentifiers'].message_type = BluePrintCommon__pb2._ACTIONIDENTIFIERS
+_BLUEPRINTREMOVEINPUT.fields_by_name['commonHeader'].message_type = BlueprintCommon__pb2._COMMONHEADER
+_BLUEPRINTREMOVEINPUT.fields_by_name['actionIdentifiers'].message_type = BlueprintCommon__pb2._ACTIONIDENTIFIERS
_BLUEPRINTREMOVEINPUT.fields_by_name['properties'].message_type = google_dot_protobuf_dot_struct__pb2._STRUCT
-_BLUEPRINTBOOTSTRAPINPUT.fields_by_name['commonHeader'].message_type = BluePrintCommon__pb2._COMMONHEADER
-_BLUEPRINTMANAGEMENTOUTPUT.fields_by_name['commonHeader'].message_type = BluePrintCommon__pb2._COMMONHEADER
+_BLUEPRINTBOOTSTRAPINPUT.fields_by_name['commonHeader'].message_type = BlueprintCommon__pb2._COMMONHEADER
+_BLUEPRINTMANAGEMENTOUTPUT.fields_by_name['commonHeader'].message_type = BlueprintCommon__pb2._COMMONHEADER
_BLUEPRINTMANAGEMENTOUTPUT.fields_by_name['fileChunk'].message_type = _FILECHUNK
-_BLUEPRINTMANAGEMENTOUTPUT.fields_by_name['status'].message_type = BluePrintCommon__pb2._STATUS
+_BLUEPRINTMANAGEMENTOUTPUT.fields_by_name['status'].message_type = BlueprintCommon__pb2._STATUS
_BLUEPRINTMANAGEMENTOUTPUT.fields_by_name['properties'].message_type = google_dot_protobuf_dot_struct__pb2._STRUCT
-DESCRIPTOR.message_types_by_name['BluePrintUploadInput'] = _BLUEPRINTUPLOADINPUT
-DESCRIPTOR.message_types_by_name['BluePrintDownloadInput'] = _BLUEPRINTDOWNLOADINPUT
-DESCRIPTOR.message_types_by_name['BluePrintRemoveInput'] = _BLUEPRINTREMOVEINPUT
-DESCRIPTOR.message_types_by_name['BluePrintBootstrapInput'] = _BLUEPRINTBOOTSTRAPINPUT
-DESCRIPTOR.message_types_by_name['BluePrintManagementOutput'] = _BLUEPRINTMANAGEMENTOUTPUT
+DESCRIPTOR.message_types_by_name['BlueprintUploadInput'] = _BLUEPRINTUPLOADINPUT
+DESCRIPTOR.message_types_by_name['BlueprintDownloadInput'] = _BLUEPRINTDOWNLOADINPUT
+DESCRIPTOR.message_types_by_name['BlueprintRemoveInput'] = _BLUEPRINTREMOVEINPUT
+DESCRIPTOR.message_types_by_name['BlueprintBootstrapInput'] = _BLUEPRINTBOOTSTRAPINPUT
+DESCRIPTOR.message_types_by_name['BlueprintManagementOutput'] = _BLUEPRINTMANAGEMENTOUTPUT
DESCRIPTOR.message_types_by_name['FileChunk'] = _FILECHUNK
DESCRIPTOR.enum_types_by_name['DownloadAction'] = _DOWNLOADACTION
DESCRIPTOR.enum_types_by_name['UploadAction'] = _UPLOADACTION
DESCRIPTOR.enum_types_by_name['RemoveAction'] = _REMOVEACTION
_sym_db.RegisterFileDescriptor(DESCRIPTOR)
-BluePrintUploadInput = _reflection.GeneratedProtocolMessageType('BluePrintUploadInput', (_message.Message,), {
+BlueprintUploadInput = _reflection.GeneratedProtocolMessageType('BlueprintUploadInput', (_message.Message,), {
'DESCRIPTOR' : _BLUEPRINTUPLOADINPUT,
- '__module__' : 'BluePrintManagement_pb2'
- # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintUploadInput)
+ '__module__' : 'BlueprintManagement_pb2'
+ # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintUploadInput)
})
-_sym_db.RegisterMessage(BluePrintUploadInput)
+_sym_db.RegisterMessage(BlueprintUploadInput)
-BluePrintDownloadInput = _reflection.GeneratedProtocolMessageType('BluePrintDownloadInput', (_message.Message,), {
+BlueprintDownloadInput = _reflection.GeneratedProtocolMessageType('BlueprintDownloadInput', (_message.Message,), {
'DESCRIPTOR' : _BLUEPRINTDOWNLOADINPUT,
- '__module__' : 'BluePrintManagement_pb2'
- # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintDownloadInput)
+ '__module__' : 'BlueprintManagement_pb2'
+ # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintDownloadInput)
})
-_sym_db.RegisterMessage(BluePrintDownloadInput)
+_sym_db.RegisterMessage(BlueprintDownloadInput)
-BluePrintRemoveInput = _reflection.GeneratedProtocolMessageType('BluePrintRemoveInput', (_message.Message,), {
+BlueprintRemoveInput = _reflection.GeneratedProtocolMessageType('BlueprintRemoveInput', (_message.Message,), {
'DESCRIPTOR' : _BLUEPRINTREMOVEINPUT,
- '__module__' : 'BluePrintManagement_pb2'
- # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintRemoveInput)
+ '__module__' : 'BlueprintManagement_pb2'
+ # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintRemoveInput)
})
-_sym_db.RegisterMessage(BluePrintRemoveInput)
+_sym_db.RegisterMessage(BlueprintRemoveInput)
-BluePrintBootstrapInput = _reflection.GeneratedProtocolMessageType('BluePrintBootstrapInput', (_message.Message,), {
+BlueprintBootstrapInput = _reflection.GeneratedProtocolMessageType('BlueprintBootstrapInput', (_message.Message,), {
'DESCRIPTOR' : _BLUEPRINTBOOTSTRAPINPUT,
- '__module__' : 'BluePrintManagement_pb2'
- # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintBootstrapInput)
+ '__module__' : 'BlueprintManagement_pb2'
+ # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintBootstrapInput)
})
-_sym_db.RegisterMessage(BluePrintBootstrapInput)
+_sym_db.RegisterMessage(BlueprintBootstrapInput)
-BluePrintManagementOutput = _reflection.GeneratedProtocolMessageType('BluePrintManagementOutput', (_message.Message,), {
+BlueprintManagementOutput = _reflection.GeneratedProtocolMessageType('BlueprintManagementOutput', (_message.Message,), {
'DESCRIPTOR' : _BLUEPRINTMANAGEMENTOUTPUT,
- '__module__' : 'BluePrintManagement_pb2'
- # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementOutput)
+ '__module__' : 'BlueprintManagement_pb2'
+ # @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementOutput)
})
-_sym_db.RegisterMessage(BluePrintManagementOutput)
+_sym_db.RegisterMessage(BlueprintManagementOutput)
FileChunk = _reflection.GeneratedProtocolMessageType('FileChunk', (_message.Message,), {
'DESCRIPTOR' : _FILECHUNK,
- '__module__' : 'BluePrintManagement_pb2'
+ '__module__' : 'BlueprintManagement_pb2'
# @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.management.api.FileChunk)
})
_sym_db.RegisterMessage(FileChunk)
DESCRIPTOR._options = None
_BLUEPRINTMANAGEMENTSERVICE = _descriptor.ServiceDescriptor(
- name='BluePrintManagementService',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService',
+ name='BlueprintManagementService',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService',
file=DESCRIPTOR,
index=0,
serialized_options=None,
methods=[
_descriptor.MethodDescriptor(
name='downloadBlueprint',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService.downloadBlueprint',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService.downloadBlueprint',
index=0,
containing_service=None,
input_type=_BLUEPRINTDOWNLOADINPUT,
),
_descriptor.MethodDescriptor(
name='uploadBlueprint',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService.uploadBlueprint',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService.uploadBlueprint',
index=1,
containing_service=None,
input_type=_BLUEPRINTUPLOADINPUT,
),
_descriptor.MethodDescriptor(
name='removeBlueprint',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService.removeBlueprint',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService.removeBlueprint',
index=2,
containing_service=None,
input_type=_BLUEPRINTREMOVEINPUT,
),
_descriptor.MethodDescriptor(
name='bootstrapBlueprint',
- full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService.bootstrapBlueprint',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService.bootstrapBlueprint',
index=3,
containing_service=None,
input_type=_BLUEPRINTBOOTSTRAPINPUT,
])
_sym_db.RegisterServiceDescriptor(_BLUEPRINTMANAGEMENTSERVICE)
-DESCRIPTOR.services_by_name['BluePrintManagementService'] = _BLUEPRINTMANAGEMENTSERVICE
+DESCRIPTOR.services_by_name['BlueprintManagementService'] = _BLUEPRINTMANAGEMENTSERVICE
# @@protoc_insertion_point(module_scope)
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc
-from proto import BluePrintManagement_pb2 as BluePrintManagement__pb2
+from proto import BlueprintManagement_pb2 as BlueprintManagement__pb2
-class BluePrintManagementServiceStub(object):
+class BlueprintManagementServiceStub(object):
# missing associated documentation comment in .proto file
pass
channel: A grpc.Channel.
"""
self.downloadBlueprint = channel.unary_unary(
- '/org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService/downloadBlueprint',
- request_serializer=BluePrintManagement__pb2.BluePrintDownloadInput.SerializeToString,
- response_deserializer=BluePrintManagement__pb2.BluePrintManagementOutput.FromString,
+ '/org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService/downloadBlueprint',
+ request_serializer=BlueprintManagement__pb2.BlueprintDownloadInput.SerializeToString,
+ response_deserializer=BlueprintManagement__pb2.BlueprintManagementOutput.FromString,
)
self.uploadBlueprint = channel.unary_unary(
- '/org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService/uploadBlueprint',
- request_serializer=BluePrintManagement__pb2.BluePrintUploadInput.SerializeToString,
- response_deserializer=BluePrintManagement__pb2.BluePrintManagementOutput.FromString,
+ '/org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService/uploadBlueprint',
+ request_serializer=BlueprintManagement__pb2.BlueprintUploadInput.SerializeToString,
+ response_deserializer=BlueprintManagement__pb2.BlueprintManagementOutput.FromString,
)
self.removeBlueprint = channel.unary_unary(
- '/org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService/removeBlueprint',
- request_serializer=BluePrintManagement__pb2.BluePrintRemoveInput.SerializeToString,
- response_deserializer=BluePrintManagement__pb2.BluePrintManagementOutput.FromString,
+ '/org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService/removeBlueprint',
+ request_serializer=BlueprintManagement__pb2.BlueprintRemoveInput.SerializeToString,
+ response_deserializer=BlueprintManagement__pb2.BlueprintManagementOutput.FromString,
)
self.bootstrapBlueprint = channel.unary_unary(
- '/org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService/bootstrapBlueprint',
- request_serializer=BluePrintManagement__pb2.BluePrintBootstrapInput.SerializeToString,
- response_deserializer=BluePrintManagement__pb2.BluePrintManagementOutput.FromString,
+ '/org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService/bootstrapBlueprint',
+ request_serializer=BlueprintManagement__pb2.BlueprintBootstrapInput.SerializeToString,
+ response_deserializer=BlueprintManagement__pb2.BlueprintManagementOutput.FromString,
)
-class BluePrintManagementServiceServicer(object):
+class BlueprintManagementServiceServicer(object):
# missing associated documentation comment in .proto file
pass
raise NotImplementedError('Method not implemented!')
-def add_BluePrintManagementServiceServicer_to_server(servicer, server):
+def add_BlueprintManagementServiceServicer_to_server(servicer, server):
rpc_method_handlers = {
'downloadBlueprint': grpc.unary_unary_rpc_method_handler(
servicer.downloadBlueprint,
- request_deserializer=BluePrintManagement__pb2.BluePrintDownloadInput.FromString,
- response_serializer=BluePrintManagement__pb2.BluePrintManagementOutput.SerializeToString,
+ request_deserializer=BlueprintManagement__pb2.BlueprintDownloadInput.FromString,
+ response_serializer=BlueprintManagement__pb2.BlueprintManagementOutput.SerializeToString,
),
'uploadBlueprint': grpc.unary_unary_rpc_method_handler(
servicer.uploadBlueprint,
- request_deserializer=BluePrintManagement__pb2.BluePrintUploadInput.FromString,
- response_serializer=BluePrintManagement__pb2.BluePrintManagementOutput.SerializeToString,
+ request_deserializer=BlueprintManagement__pb2.BlueprintUploadInput.FromString,
+ response_serializer=BlueprintManagement__pb2.BlueprintManagementOutput.SerializeToString,
),
'removeBlueprint': grpc.unary_unary_rpc_method_handler(
servicer.removeBlueprint,
- request_deserializer=BluePrintManagement__pb2.BluePrintRemoveInput.FromString,
- response_serializer=BluePrintManagement__pb2.BluePrintManagementOutput.SerializeToString,
+ request_deserializer=BlueprintManagement__pb2.BlueprintRemoveInput.FromString,
+ response_serializer=BlueprintManagement__pb2.BlueprintManagementOutput.SerializeToString,
),
'bootstrapBlueprint': grpc.unary_unary_rpc_method_handler(
servicer.bootstrapBlueprint,
- request_deserializer=BluePrintManagement__pb2.BluePrintBootstrapInput.FromString,
- response_serializer=BluePrintManagement__pb2.BluePrintManagementOutput.SerializeToString,
+ request_deserializer=BlueprintManagement__pb2.BlueprintBootstrapInput.FromString,
+ response_serializer=BlueprintManagement__pb2.BlueprintManagementOutput.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
- 'org.onap.ccsdk.cds.controllerblueprints.management.api.BluePrintManagementService', rpc_method_handlers)
+ 'org.onap.ccsdk.cds.controllerblueprints.management.api.BlueprintManagementService', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
# limitations under the License.
# Generated by the protocol buffer compiler. DO NOT EDIT!
-# source: BluePrintProcessing.proto
+# source: BlueprintProcessing.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
-from proto import BluePrintCommon_pb2 as BluePrintCommon__pb2
+from proto import BlueprintCommon_pb2 as BlueprintCommon__pb2
DESCRIPTOR = _descriptor.FileDescriptor(
- name='BluePrintProcessing.proto',
+ name='BlueprintProcessing.proto',
package='org.onap.ccsdk.cds.controllerblueprints.processing.api',
syntax='proto3',
serialized_options=_b('P\001'),
serialized_pb=_b('\n\x19\x42luePrintProcessing.proto\x12\x36org.onap.ccsdk.cds.controllerblueprints.processing.api\x1a\x1cgoogle/protobuf/struct.proto\x1a\x15\x42luePrintCommon.proto\"\xfb\x01\n\x15\x45xecutionServiceInput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12`\n\x11\x61\x63tionIdentifiers\x18\x02 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12(\n\x07payload\x18\x03 \x01(\x0b\x32\x17.google.protobuf.Struct\"\xc8\x02\n\x16\x45xecutionServiceOutput\x12V\n\x0c\x63ommonHeader\x18\x01 \x01(\x0b\x32@.org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader\x12`\n\x11\x61\x63tionIdentifiers\x18\x02 \x01(\x0b\x32\x45.org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers\x12J\n\x06status\x18\x03 \x01(\x0b\x32:.org.onap.ccsdk.cds.controllerblueprints.common.api.Status\x12(\n\x07payload\x18\x04 \x01(\x0b\x32\x17.google.protobuf.Struct2\xcb\x01\n\x1a\x42luePrintProcessingService\x12\xac\x01\n\x07process\x12M.org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput\x1aN.org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput(\x01\x30\x01\x42\x02P\x01\x62\x06proto3')
,
- dependencies=[google_dot_protobuf_dot_struct__pb2.DESCRIPTOR,BluePrintCommon__pb2.DESCRIPTOR,])
+ dependencies=[google_dot_protobuf_dot_struct__pb2.DESCRIPTOR,BlueprintCommon__pb2.DESCRIPTOR,])
serialized_end=721,
)
-_EXECUTIONSERVICEINPUT.fields_by_name['commonHeader'].message_type = BluePrintCommon__pb2._COMMONHEADER
-_EXECUTIONSERVICEINPUT.fields_by_name['actionIdentifiers'].message_type = BluePrintCommon__pb2._ACTIONIDENTIFIERS
+_EXECUTIONSERVICEINPUT.fields_by_name['commonHeader'].message_type = BlueprintCommon__pb2._COMMONHEADER
+_EXECUTIONSERVICEINPUT.fields_by_name['actionIdentifiers'].message_type = BlueprintCommon__pb2._ACTIONIDENTIFIERS
_EXECUTIONSERVICEINPUT.fields_by_name['payload'].message_type = google_dot_protobuf_dot_struct__pb2._STRUCT
-_EXECUTIONSERVICEOUTPUT.fields_by_name['commonHeader'].message_type = BluePrintCommon__pb2._COMMONHEADER
-_EXECUTIONSERVICEOUTPUT.fields_by_name['actionIdentifiers'].message_type = BluePrintCommon__pb2._ACTIONIDENTIFIERS
-_EXECUTIONSERVICEOUTPUT.fields_by_name['status'].message_type = BluePrintCommon__pb2._STATUS
+_EXECUTIONSERVICEOUTPUT.fields_by_name['commonHeader'].message_type = BlueprintCommon__pb2._COMMONHEADER
+_EXECUTIONSERVICEOUTPUT.fields_by_name['actionIdentifiers'].message_type = BlueprintCommon__pb2._ACTIONIDENTIFIERS
+_EXECUTIONSERVICEOUTPUT.fields_by_name['status'].message_type = BlueprintCommon__pb2._STATUS
_EXECUTIONSERVICEOUTPUT.fields_by_name['payload'].message_type = google_dot_protobuf_dot_struct__pb2._STRUCT
DESCRIPTOR.message_types_by_name['ExecutionServiceInput'] = _EXECUTIONSERVICEINPUT
DESCRIPTOR.message_types_by_name['ExecutionServiceOutput'] = _EXECUTIONSERVICEOUTPUT
ExecutionServiceInput = _reflection.GeneratedProtocolMessageType('ExecutionServiceInput', (_message.Message,), {
'DESCRIPTOR' : _EXECUTIONSERVICEINPUT,
- '__module__' : 'BluePrintProcessing_pb2'
+ '__module__' : 'BlueprintProcessing_pb2'
# @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput)
})
_sym_db.RegisterMessage(ExecutionServiceInput)
ExecutionServiceOutput = _reflection.GeneratedProtocolMessageType('ExecutionServiceOutput', (_message.Message,), {
'DESCRIPTOR' : _EXECUTIONSERVICEOUTPUT,
- '__module__' : 'BluePrintProcessing_pb2'
+ '__module__' : 'BlueprintProcessing_pb2'
# @@protoc_insertion_point(class_scope:org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput)
})
_sym_db.RegisterMessage(ExecutionServiceOutput)
DESCRIPTOR._options = None
_BLUEPRINTPROCESSINGSERVICE = _descriptor.ServiceDescriptor(
- name='BluePrintProcessingService',
- full_name='org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingService',
+ name='BlueprintProcessingService',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingService',
file=DESCRIPTOR,
index=0,
serialized_options=None,
methods=[
_descriptor.MethodDescriptor(
name='process',
- full_name='org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingService.process',
+ full_name='org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingService.process',
index=0,
containing_service=None,
input_type=_EXECUTIONSERVICEINPUT,
])
_sym_db.RegisterServiceDescriptor(_BLUEPRINTPROCESSINGSERVICE)
-DESCRIPTOR.services_by_name['BluePrintProcessingService'] = _BLUEPRINTPROCESSINGSERVICE
+DESCRIPTOR.services_by_name['BlueprintProcessingService'] = _BLUEPRINTPROCESSINGSERVICE
# @@protoc_insertion_point(module_scope)
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc
-from proto import BluePrintProcessing_pb2 as BluePrintProcessing__pb2
+from proto import BlueprintProcessing_pb2 as BlueprintProcessing__pb2
-class BluePrintProcessingServiceStub(object):
+class BlueprintProcessingServiceStub(object):
# missing associated documentation comment in .proto file
pass
channel: A grpc.Channel.
"""
self.process = channel.stream_stream(
- '/org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingService/process',
- request_serializer=BluePrintProcessing__pb2.ExecutionServiceInput.SerializeToString,
- response_deserializer=BluePrintProcessing__pb2.ExecutionServiceOutput.FromString,
+ '/org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingService/process',
+ request_serializer=BlueprintProcessing__pb2.ExecutionServiceInput.SerializeToString,
+ response_deserializer=BlueprintProcessing__pb2.ExecutionServiceOutput.FromString,
)
-class BluePrintProcessingServiceServicer(object):
+class BlueprintProcessingServiceServicer(object):
# missing associated documentation comment in .proto file
pass
raise NotImplementedError('Method not implemented!')
-def add_BluePrintProcessingServiceServicer_to_server(servicer, server):
+def add_BlueprintProcessingServiceServicer_to_server(servicer, server):
rpc_method_handlers = {
'process': grpc.stream_stream_rpc_method_handler(
servicer.process,
- request_deserializer=BluePrintProcessing__pb2.ExecutionServiceInput.FromString,
- response_serializer=BluePrintProcessing__pb2.ExecutionServiceOutput.SerializeToString,
+ request_deserializer=BlueprintProcessing__pb2.ExecutionServiceInput.FromString,
+ response_serializer=BlueprintProcessing__pb2.ExecutionServiceOutput.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
- 'org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingService', rpc_method_handlers)
+ 'org.onap.ccsdk.cds.controllerblueprints.processing.api.BlueprintProcessingService', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
Code Review / ccsdk / cds.git / commitdiff