<artifactId>ne-location-provider</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>vpp-renderer</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>neutron-mapper</artifactId>
<type>xml</type>
<classifier>config</classifier>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>vpp-renderer</artifactId>
+ <version>${project.version}</version>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>neutron-mapper</artifactId>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>ne-location-provider</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>vpp-renderer</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>neutron-mapper</artifactId>
<type>xml</type>
<classifier>config</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>vpp-renderer</artifactId>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>neutron-mapper</artifactId>
<configfile finalname="${config.configfile.directory}/15-groupbasedpolicy-netconf.xml">mvn:org.opendaylight.groupbasedpolicy/netconf-renderer/{{VERSION}}/xml/config</configfile>
</feature>
-
<!--
The Neutron provider
-->
<feature name='odl-groupbasedpolicy-neutronmapper' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: Neutron Mapper mapps neutron APIs to GBP APIs '>
<feature version="${neutron.version}">odl-neutron-service</feature>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
- <feature version="${project.version}">odl-groupbasedpolicy-ofoverlay</feature>
<bundle>mvn:org.opendaylight.neutron/dummyprovider/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}}</bundle>
- <bundle>mvn:org.opendaylight.groupbasedpolicy/neutron-ovsdb/{{VERSION}}</bundle>
<configfile finalname="${config.configfile.directory}/15-neutron-mapper.xml">mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}}/xml/config</configfile>
+ </feature>
+
+ <!--
+ The Neutron provider and OFOVERLAY renderer
+ -->
+ <feature name='odl-groupbasedpolicy-neutron-and-ofoverlay' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: Neutron Mapper mapps neutron APIs to GBP APIs '>
+ <feature version="${project.version}">odl-groupbasedpolicy-ofoverlay</feature>
+ <feature version="${project.version}">odl-groupbasedpolicy-neutronmapper</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/neutron-ovsdb/{{VERSION}}</bundle>
<configfile finalname="${config.configfile.directory}/15-neutron-ovsdb.xml">mvn:org.opendaylight.groupbasedpolicy/neutron-ovsdb/{{VERSION}}/xml/config</configfile>
</feature>
+ <!--
+ The VPP renderer
+ -->
+ <feature name='odl-groupbasedpolicy-vpp' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: VPP renderer '>
+ <feature version="${project.version}">odl-groupbasedpolicy-base</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/vpp-renderer/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-vpp-renderer.xml">mvn:org.opendaylight.groupbasedpolicy/vpp-renderer/{{VERSION}}/xml/config</configfile>
+ </feature>
+
<!--
The UI Backend
-->
angular.module('app.gbp').controller('RootGbpCtrl', RootGbpCtrl);
- RootGbpCtrl.$inject = ['$state', '$scope', 'RootGbpService'];
+ RootGbpCtrl.$inject = ['$state', '$scope', 'RootGbpService', 'TenantListService', 'TenantService', 'ContractService'];
- function RootGbpCtrl($state, $scope, RootGbpService) {
+ function RootGbpCtrl($state, $scope, RootGbpService, TenantListService, TenantService, ContractService) {
/* properties */
$scope.stateUrl = null;
$scope.sidePanelPage = false;
+ $scope.rootTenant = TenantService.createObject();
+ $scope.rootTenants = TenantListService.createList();
+ $scope.policyDisabled = true;
/* methods */
+ $scope.broadcastFromRoot = broadcastFromRoot;
$scope.closeSidePanel = closeSidePanel;
$scope.openSidePanel = openSidePanel;
+ $scope.setRootTenant = setRootTenant;
RootGbpService.setMainClass();
console.log('RootGbpCtrl initialized');
+ init();
+
/* implementations */
/**
* Sets '$scope.sidePanelPage' to false. This variable is watched in index.tpl.html template
* and opens/closes side panel
*/
+ function init() {
+ $scope.rootTenants.clearData();
+ $scope.rootTenants.get('config');
+ }
+
+ function broadcastFromRoot(eventName, val) {
+ $scope.$broadcast(eventName, val);
+ }
+
+ function setRootTenant() {
+ $scope.broadcastFromRoot('ROOT_TENANT_CHANGED');
+ enableButtons();
+ }
+
function closeSidePanel() {
$scope.sidePanelPage = false;
}
$scope.sidePanelPage = true;
}
+ function enableButtons() {
+ $scope.policyDisabled = false;
+ }
/* event listeners */
/**
* Event fired after content loaded, setStateUrl function is called to fill stateUrl method
.gbpUiWrapper .md-table span {
color: rgba(0,0,0,.87);
}
+.gbpUiWrapper .md-table-pagination span {
+ color: rgba(0,0,0,.87);
+ font-weight: normal;
+}
+.gbpUiWrapper button.md-button.md-icon-button.w85 {
+ width: 85px;
+}
/* BUTTONS */
.gbpUiWrapper button.md-primary span {
color: rgb(33,150,243);
}
+.gbpUiWrapper button .md-icon {
+ width: 30px;
+}
+
+/* DIALOG */
+.gbpDialogWrapper button.md-primary span {
+ color: rgba(0,0,0,0.87);
+}
+.gbpDialogWrapper button.md-primary[disabled] span {
+ color: rgba(0,0,0,0.26);
+}
+
+/* $mdDialog.confirm */
+md-dialog button span {
+ color: #000;
+}
\ No newline at end of file
/*$translatePartialLoaderProvider.addPart('app/gbp/assets/data/locale');*/
NavHelperProvider.addControllerUrl('app/gbp/common/gbp.controller');
+ NavHelperProvider.addControllerUrl('app/gbp/contract/add-contract.controller');
NavHelperProvider.addControllerUrl('app/gbp/contract/contract.controller');
NavHelperProvider.addControllerUrl('app/gbp/epg/epg.controller');
NavHelperProvider.addControllerUrl('app/gbp/policy/policy.controller');
access: access.admin,
templateUrl: 'src/app/gbp/common/views/index.tpl.html',
views: {
- '': {
- controller: 'PolicyController',
- templateUrl: 'src/app/gbp/policy/policy.tpl.html',
+ 'main_top': {
+ controller: 'EpgController',
+ templateUrl: 'src/app/gbp/epg/epg.tpl.html',
+ },
+ 'main_bottom': {
+ controller: 'ContractController',
+ templateUrl: 'src/app/gbp/contract/contract.tpl.html',
},
},
});
},
});
- $stateProvider.state('main.gbp.index.policy.contract', {
- url: '/contract',
+ $stateProvider.state('main.gbp.index.contract', {
+ url: '/policy/contract',
access: access.admin,
templateUrl: 'src/app/gbp/common/views/index.tpl.html',
views: {
'': {
- controller: 'PolicyController',
- templateUrl: 'src/app/gbp/policy/policy.tpl.html',
+ controller: 'ContractController',
+ templateUrl: 'src/app/gbp/contract/contract.tpl.html',
},
- 'sidePanel': {
+ },
+ });
+
+ $stateProvider.state('main.gbp.index.contractId', {
+ url: '/policy/contract/{contractId}',
+ access: access.admin,
+ templateUrl: 'src/app/gbp/common/views/index.tpl.html',
+ views: {
+ '': {
controller: 'ContractController',
templateUrl: 'src/app/gbp/contract/contract.tpl.html',
},
<md-toolbar>
<div class="md-toolbar-tools">
<md-button ng-href="#/gbp/index/tenant" ng-click="closeSidePanel()" class="md-primary">Tenant</md-button>
- <md-button ng-href="#/gbp/index/policy" ng-click="closeSidePanel()" class="md-primary">Policy</md-button>
+ <!-- <md-button ng-href="#/gbp/index/policy" ng-click="closeSidePanel()" class="md-primary">Policy</md-button> -->
+
+ <md-menu class="md-primary" class="md-toolbar-tools" style="background-color:rgb(33,150,243);color:black;">
+ <md-button ng-click="$mdOpenMenu($event)" style="background-color:rgb(33,150,243);color:black;">Policy</md-button>
+ <md-menu-content style="background-color:rgb(33,150,243);color:black;">
+ <md-button ng-click="" ng-disabled="policyDisabled" ng-href="#/gbp/index/policy/epg" style="background-color:rgb(33,150,243);color:black;">EPGs</md-button>
+ <md-button ng-click="" ng-disabled="policyDisabled" ng-href="#/gbp/index/policy/contract" style="background-color:rgb(33,150,243);color:black;">Contracts</md-button>
+ </md-menu-content>
+ </md-menu>
+
<span flex></span>
- <md-button ng-if="stateUrl === '/policy'" ng-href="#/gbp/index/policy/epg" ng-click="openSidePanel()" class="md-primary">EPGs</md-button>
- <md-button ng-if="stateUrl === '/policy'" ng-href="#/gbp/index/policy/contract" ng-click="openSidePanel()" class="md-primary">Contracts</md-button>
+ <md-select ng-model="rootTenant" ng-change="setRootTenant()">
+ <md-option ng-repeat="item in rootTenants.data" ng-value="{{item}}">{{item.data.id}}</md-option>
+ </md-select>
+ <!-- <md-button ng-if="stateUrl === '/policy'" ng-href="#/gbp/index/policy/epg" ng-click="openSidePanel()" class="md-primary">EPGs</md-button>
+ <md-button ng-if="stateUrl === '/policy'" ng-href="#/gbp/index/policy/contract" ng-click="openSidePanel()" class="md-primary">Contracts</md-button> -->
</div>
</md-toolbar>
- <md-content md-scroll-y flex ui-view></md-content>
+ <!-- <md-content md-scroll-y flex ui-view></md-content> -->
+ <md-content md-scroll-y flex ui-view>
+ <md-content md-scroll-y flex ui-view="main_top" class="col-md-6"></md-content>
+ <md-content md-scroll-y flex ui-view="main_bottom" class="col-md-6"></md-content>
+ </md-content>
</div>
- <md-sidenav class="md-sidenav-right md-whiteframe-z1 detail-view" md-is-locked-open="sidePanelPage">
+ <!-- <md-sidenav class="md-sidenav-right md-whiteframe-z1 detail-view" md-is-locked-open="sidePanelPage">
<md-toolbar>
<div class="md-toolbar-tools">
<h2>
<md-content flex>
<div flex layout="column" ui-view="sidePanel"></div>
</md-content>
- </md-sidenav>
+ </md-sidenav> -->
</div>
--- /dev/null
+define([
+ 'app/gbp/contract/contract.service'
+], function () {
+ 'use strict';
+
+ angular.module('app.gbp').controller('AddContractController', AddContractController);
+
+ AddContractController.$inject = ['$mdDialog', '$scope', 'ContractService', 'contract'];
+ /* @ngInject */
+ function AddContractController($mdDialog, $scope, ContractService, contract) {
+ /* properties */
+ $scope.contract = contract ? contract : ContractService.createObject();
+
+ /* methods */
+ $scope.closeDialog = closeDialog;
+ $scope.save = save;
+ /* Implementations */
+
+ function closeDialog(){
+ $mdDialog.cancel();
+ $scope.getContractList();
+ }
+
+ function save() {
+ $scope.contract.put($scope.rootTenant.data.id, function (data) {
+ $scope.closeDialog();
+ }, function (err) {
+ } );
+ }
+
+ }
+});
--- /dev/null
+define([], function () {
+ 'use strict';
+
+ angular.module('app.gbp').service('ContractListService', ContractListService);
+
+ ContractListService.$inject = ['Restangular', 'ContractService'];
+
+ function ContractListService(Restangular, ContractService) {
+ /* methods */
+ this.createList = createList;
+
+ function ContractList() {
+ /* properties */
+ this.data = [];
+
+ /* methods */
+ this.setData = setData;
+ this.get = get;
+ this.clearData = clearData;
+
+ /* Implementation */
+ /**
+ * fills ContractList object with data
+ * @param data
+ */
+ function setData(data) {
+ var self = this;
+ data.forEach(function (dataElement) {
+ self.data.push(ContractService.createObject(dataElement));
+ });
+ }
+
+ function clearData() {
+ var self = this;
+ self.data = [];
+ }
+
+ function get(tenantId) {
+ /* jshint validthis:true */
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants')
+ .one('tenant').one(tenantId).one('policy');
+
+ return restObj.get().then(function (data) {
+ self.setData(data.policy.contract);
+ });
+ }
+ }
+
+ function createList() {
+ var obj = new ContractList();
+
+ return obj;
+ }
+ }
+
+ return ContractListService;
+});
define([
-
+ 'app/gbp/contract/contract.service',
+ 'app/gbp/contract/contract-list.service',
], function () {
'use strict';
angular.module('app.gbp').controller('ContractController', ContractController);
- ContractController.$inject = ['$scope'];
+ ContractController.$inject = ['$mdDialog', '$scope', 'TenantListService', 'TenantService', 'ContractService', 'ContractListService', '$stateParams'];
+
+ function ContractController($mdDialog, $scope, TenantListService, TenantService, ContractService, ContractListService, $stateParams) {
+ $scope.contracts = ContractListService.createList();
+ $scope.openContractDialog = openContractDialog;
+ $scope.contractsTableQuery = {
+ order: 'data.id',
+ limit: 25,
+ page: 1,
+ options: [25, 50, 100],
+ filter: '',
+ };
+ $scope.getContractList = getContractList;
+ $scope.deleteContractDialog = deleteContractDialog;
+
+ getContractList();
+
+ function getContractList() {
+ $scope.contracts.clearData();
+ $scope.contracts.get($scope.rootTenant.data.id);
+ }
+
+ function openContractDialog(contractData) {
+ $mdDialog.show({
+ clickOutsideToClose: true,
+ controller: 'AddContractController',
+ preserveScope: true,
+ templateUrl: 'src/app/gbp/contract/dialog-add-contract.tpl.html',
+ parent: angular.element(document.body),
+ scope: $scope,
+ locals: {
+ contract: contractData,
+ },
+ });
+ }
+
+ function deleteContractDialog(contractData) {
+ var confirm = $mdDialog.confirm()
+ .title('Delete contract')
+ .textContent('Do you want to delete contract ' + contractData.data.id + '?')
+ .ok('Delete')
+ .cancel('Cancel');
+
+ $mdDialog.show(confirm).then(function () {
+ contractData.deleteContract($scope.rootTenant.data.id,
+ function () {
+ $scope.getContractList();
+ }
+ );
+ }, function () {
- function ContractController($scope) {
+ });
+ }
+ $scope.$on('ROOT_TENANT_CHANGED', getContractList);
}
});
--- /dev/null
+define([], function () {
+ 'use strict';
+
+ angular.module('app.gbp').service('ContractService', ContractService);
+
+ ContractService.$inject = ['Restangular'];
+
+ function ContractService(Restangular) {
+ /* methods */
+ this.createObject = createObject;
+
+ /**
+ * Contract constructor
+ * @constructor
+ */
+ function Contract() {
+ /* properties */
+ this.data = {};
+ /* methods */
+ this.setData = setData;
+ this.get = get;
+ this.put = put;
+ this.deleteContract = deleteContract;
+
+ /* Implementation */
+ /**
+ * fills Contract object with data
+ * @param data
+ */
+ function setData(data) {
+ this.data.id = data.id;
+ this.data.description = data.description;
+ this.data.parent = data.parent;
+
+ // TODO: use objects
+ this.data['forwarding-context'] = data['forwarding-context'];
+ this.data.target = data.target;
+ this.data.subject = data.subject;
+ this.data.clause = data.clause;
+ this.data.quality = data.quality;
+ }
+
+ /**
+ * gets one Contract object from Restconf
+ * @param id
+ * @returns {*}
+ */
+ function get(id) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants')
+ .one('tenant').one(id).one('policy').one('contract').one(id);
+
+ return restObj.get().then(function (data) {
+ self.setData(data.contract[0]);
+ });
+ }
+
+ function put(id, successCallback) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants').one('tenant')
+ .one(id).one('policy').one('contract').one(self.data.id),
+ dataObj = { contract: [self.data] };
+
+ return restObj.customPUT(dataObj).then(function (data) {
+ successCallback(data);
+ }, function (res) {
+
+ });
+ }
+
+ function deleteContract(id, successCallback) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants').one('tenant')
+ .one(id).one('policy').one('contract').one(self.data.id);
+
+ return restObj.remove().then(function (data) {
+ successCallback(data);
+ }, function (res) {
+
+ });
+ }
+
+ }
+
+ /**
+ * creates Contract object and fills it with data if available
+ * @param data
+ * @returns {Contract}
+ */
+ function createObject(data) {
+ var obj = new Contract();
+
+ if (data) {
+ obj.setData(data);
+ }
+
+ return obj;
+ }
+ }
+
+ return ContractService;
+});
+<section flex layout="column">
+ <div flex layout="row">
+ <md-button ng-click="openContractDialog()" class="md-primary">Add</md-button>
+ <md-button ng-click="getContractList()" class="md-primary">Reload</md-button>
+ </div>
+ <md-table-container ng-if="contracts.data.length" ng-hide="contractId.length">
+ <table md-table>
+ <thead md-head md-order="contractsTableQuery.order">
+ <tr md-row>
+ <th md-column md-order-by="data.id"><span>Id</span></th>
+ <th md-column md-order-by="data.parent"><span>Parent</span></th>
+ <th md-column md-order-by="data.description"><span>Description</span></th>
+ <th md-column><span>Actions</span></th>
+ </tr>
+ </thead>
+ <tbody md-body>
+ <tr md-row ng-repeat="contract in contracts.data | filter: contractsTableQuery.filter | orderBy : contractsTableQuery.order | limitTo: contractsTableQuery.limit : (contractsTableQuery.page -1) * contractsTableQuery.limit">
+ <td md-cell>{{contract.data.id}}</td>
+ <td md-cell>{{contract.data.parent}}</td>
+ <td md-cell>{{contract.data.description}}</td>
+ <td md-cell>
+ <md-button class="md-icon-button" ng-click="openContractDialog(contract)">
+ <md-icon>edit</md-icon>
+ </md-button>
+ <md-button class="md-icon-button" ng-click="deleteContractDialog(contract)">
+ <md-icon>delete</md-icon>
+ </md-button>
+ </td>
+ </tr>
+
+ </tbody>
+ </table>
+ <md-table-pagination md-limit="contractsTableQuery.limit"
+ md-page="contractsTableQuery.page"
+ md-options="contractsTableQuery.options"
+ md-total="{{contracts.data.length}}"
+ md-page-select="options.pageSelect">
+ </md-table-pagination>
+ </md-table-container>
+
+ <section ng-if="contractId.length">
+ Details of contract: <u>{{contract1}}</u><br /><br />
+ <u>contract1:</u><br />
+ id: {{contract.data.id}}<br />
+ description: {{contract.data.description}}<br />
+ parent:{{contract.data.parent}}<br />
+ his containers:</b><br />
+ <u>Target object:</u><br />{{contract.data.target}}
+ <u>Subject object:</u><br />{{contract.data.subject}}
+ <u>Clause object:</u><br />{{contract.data.clause}}
+ <u>Quality object:</u><br />{{contract.data.quality}}
+ </section>
+
+</section>
--- /dev/null
+<md-dialog ng-cloak class="gbpDialogWrapper">
+ <form name="contractForm">
+ <md-toolbar>
+ <div class="md-toolbar-tools">
+ <h2>contract</h2>
+ <span flex></span>
+ <md-button ng-click="closeDialog()" class="md-button">Close dialog</md-button>
+ </div>
+ </md-toolbar>
+ <md-dialog-content style="width:350px;">
+ <div layout="column" class="layout-padding-lr15">
+ <div layout="row">
+ <md-input-container flex>
+ <label>Id</label>
+ <input name="id" ng-model="contract.data.id" ng-required="true">
+ <div ng-messages="contractForm.id.$error">
+ <div ng-message="required">Required field</div>
+ </div>
+ </md-input-container>
+ <md-input-container flex>
+ <label>Parent</label>
+ <input name="parent" ng-model="contract.data.parent" ng-pattern="/^[a-zA-Z]([a-zA-Z0-9\\-_.])*$/" ng-required="true">
+ <div ng-messages="contractForm.parent.$error">
+ <div ng-message="required">Required field.</div>
+ <div ng-message="pattern">
+ Invalid pattern.
+ <md-tooltip md-direction="right" style="padding-left: 10px;">Value must match: ^[a-zA-Z]([a-zA-Z0-9\\-_.])*$</md-tooltip>
+ </div>
+ </div>
+ </md-input-container>
+ </div>
+ <div layout="row">
+ <md-input-container flex>
+ <label>Description</label>
+ <input name="description" ng-model="contract.data.description">
+ </md-input-container>
+ </div>
+ </div>
+ </md-dialog-content>
+ <md-dialog-actions layout="row">
+ <span flex></span>
+ <md-button ng-click="closeDialog()" class="md-primary">
+ Close
+ </md-button>
+ <md-button ng-click="save()" style="margin-right:20px;" ng-disabled="contractForm.$invalid" class="md-primary">
+ Save
+ </md-button>
+ </md-dialog-actions>
+ </form>
+</md-dialog>
--- /dev/null
+define([
+ 'app/gbp/epg/epg.service'
+], function () {
+ 'use strict';
+
+ angular.module('app.gbp').controller('AddEpgController', AddEpgController);
+
+ AddEpgController.$inject = ['$mdDialog', '$scope', 'EpgService', 'epg'];
+ /* @ngInject */
+ function AddEpgController($mdDialog, $scope, EpgService, epg) {
+ /* properties */
+ $scope.epg = epg ? epg : EpgService.createObject();
+
+ /* methods */
+ $scope.closeDialog = closeDialog;
+ $scope.save = save;
+
+ /* Implementations */
+
+ function closeDialog(){
+ $mdDialog.cancel();
+ $scope.getEpgList();
+ }
+
+ function save() {
+ $scope.epg.put($scope.rootTenant, function(data) {
+ $scope.closeDialog();
+ }, function(err) {
+ } );
+ }
+ }
+});
--- /dev/null
+<md-dialog ng-cloak class="gbpDialogWrapper">
+ <form name="epgForm">
+ <md-toolbar>
+ <div class="md-toolbar-tools">
+ <h2>EPG</h2>
+ <span flex></span>
+ <md-button ng-click="closeDialog()" class="md-button">Close dialog</md-button>
+ </div>
+ </md-toolbar>
+ <md-dialog-content style="width:350px;">
+ <div layout="column" class="layout-padding-lr15">
+ <div layout="row">
+ <md-input-container flex>
+ <label>Id</label>
+ <input name="id" ng-model="epg.data.id" ng-required="true">
+ <div ng-messages="epgForm.id.$error" md-auto-hide="false">
+ <div ng-message="required">Required field</div>
+ </div>
+ </md-input-container>
+ <md-input-container flex>
+ <label>Name</label>
+ <input name="name" ng-model="epg.data.name" ng-required="true" ng-pattern="/^[a-zA-Z]([a-zA-Z0-9\\-_.])*$/">
+ <div ng-messages="epgForm.name.$error" md-auto-hide="false">
+ <div ng-message="required">Required field</div>
+ <div ng-message="pattern">
+ Invalid pattern.
+ <md-tooltip md-direction="right" style="padding-left: 10px;">Value must matches: ^[a-zA-Z]([a-zA-Z0-9\\-_.])*$</md-tooltip>
+ </div>
+ </div>
+ </md-input-container>
+ </div>
+ <div layout="row">
+ <md-input-container flex>
+ <label>Description</label>
+ <input name="description" ng-model="epg.data.description">
+ </md-input-container>
+ </div>
+ <div layout="row">
+ <md-input-container flex>
+ <label>intra-group-policy</label>
+ <md-select name="intraGroupPolicy" ng-model="epg.data['intra-group-policy']">
+ <md-option ng-repeat="igp in ['', 'allow', 'require-contract']" ng-value="igp">{{igp}}</md-option>
+ </md-select>
+ </md-input-container>
+ </div>
+ <div layout="row">
+ <md-input-container flex>
+ <label>network-domain</label>
+ <input name="networkDomain" ng-model="epg.data['network-domain']">
+ </md-input-container>
+ <md-input-container flex>
+ <label>parent</label>
+ <input name="parent" ng-model="epg.data.parent">
+ </md-input-container>
+ </div>
+ </div>
+ </md-dialog-content>
+ <md-dialog-actions layout="row">
+ <span flex></span>
+ <md-button ng-click="closeDialog()" class="md-primary">
+ Close
+ </md-button>
+ <md-button ng-click="save()" style="margin-right:20px;" ng-disabled="epgForm.$invalid" class="md-primary">
+ Save
+ </md-button>
+ </md-dialog-actions>
+ </form>
+</md-dialog>
--- /dev/null
+define([], function() {
+ 'use strict';
+
+ angular.module('app.gbp').service('EpgListService', EpgListService);
+
+ EpgListService.$inject = ['Restangular', 'EpgService'];
+
+ function EpgListService(Restangular, EpgService) {
+ /* methods */
+ this.createList = createList;
+
+ function EpgList() {
+ /* properties */
+ this.data = [];
+ /* methods */
+ this.setData = setData;
+ this.get = get;
+
+ /* Implementation */
+ /**
+ * fills EpgList object with data
+ * @param data
+ */
+ function setData(data) {
+ var self = this;
+ data.forEach(function(dataElement) {
+ self.data.push(EpgService.createObject(dataElement));
+ });
+ }
+
+ function get(dataStore, idTenant) {
+ /* jshint validthis:true */
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one(dataStore).one('policy:tenants').one('tenant').one(idTenant).one('policy');
+
+ return restObj.get().then(function(data) {
+ if (data.policy['endpoint-group']) {
+ self.setData(data.policy['endpoint-group']);
+ }
+ });
+ }
+ }
+
+ function createList() {
+ var obj = new EpgList();
+
+ return obj;
+ }
+ }
+
+ return EpgListService;
+});
\ No newline at end of file
define([
-
-], function () {
+ 'app/gbp/epg/epg.service',
+ 'app/gbp/epg/epg-list.service',
+], function() {
'use strict';
angular.module('app.gbp').controller('EpgController', EpgController);
- EpgController.$inject = ['$scope'];
+ EpgController.$inject = ['$scope', '$stateParams', '$mdDialog', 'EpgService', 'EpgListService'];
+
+ function EpgController($scope, $stateParams, $mdDialog, EpgService, EpgListService) {
+ $scope.epgsTableQuery = {};
+
+ // $scope.epg = EpgService.createObject();
+ // $scope.epg.get($stateParams.epgId, $stateParams.tenantId);
+
+ $scope.epgs = EpgListService.createList();
+
+ /* methods */
+ $scope.getEpgList = getEpgList;
+ $scope.openEpgDialog = openEpgDialog;
+ $scope.deleteEpgDialog = deleteEpgDialog;
+
+ init();
+
+ /* Implementations */
+
+ /**
+ * fills $scope.epgs array with data from data store
+ */
+ function getEpgList() {
+ if($stateParams.tenantId) {
+ $scope.epgs = EpgListService.createList();
+ $scope.epgs.get('config', $stateParams.tenantId);
+ }
+ else {
+ $scope.epgs = EpgListService.createList();
+ $scope.epgs.get('config', $scope.rootTenant);
+ }
+ }
+
+ /**
+ * Initializing function
+ */
+ function init() {
+ $scope.epgsTableQuery = {
+ order: 'data.id',
+ limit: 25,
+ page: 1,
+ options: [25, 50, 100],
+ filter: ''
+ };
+
+ getEpgList();
+ }
+
+ function openEpgDialog(epgData) {
+ $mdDialog.show({
+ clickOutsideToClose: true,
+ controller: 'AddEpgController',
+ preserveScope: true,
+ templateUrl: 'src/app/gbp/epg/dialog-add-epg.tpl.html',
+ parent: angular.element(document.body),
+ scope: $scope,
+ locals: {
+ epg: epgData
+ }
+ });
+ }
+
+ function deleteEpgDialog(epgData) {
+ var confirm = $mdDialog.confirm()
+ .title('Delete EPG')
+ .textContent('Do you want to delete EPG ' + epgData.data.name + '?')
+ .ok('Delete')
+ .cancel('Cancel');
- function EpgController($scope) {
+ $mdDialog.show(confirm).then(function() {
+ epgData.deleteEpg($scope.rootTenant,
+ function() {
+ $scope.getEpgList();
+ }
+ );
+ }, function() {
+ });
+ }
}
-});
+});
\ No newline at end of file
--- /dev/null
+define([], function() {
+ 'use strict';
+
+ angular.module('app.gbp').service('EpgService', EpgService);
+
+ EpgService.$inject = ['Restangular'];
+
+ function EpgService(Restangular) {
+ /* methods */
+ this.createObject = createObject;
+
+
+ /**
+ * Epg constructor
+ * @constructor
+ */
+ function Epg() {
+ /* properties */
+ this.data = {};
+ /* methods */
+ this.setData = setData;
+ this.get = get;
+ this.put = put;
+ this.deleteEpg = deleteEpg;
+
+ /* Implementation */
+ /**
+ * fills Epg object with data
+ * @param data
+ */
+ function setData(data) {
+ this.data.id = data.id;
+ this.data.name = data.name;
+ this.data.description = data.description;
+ this.data['intra-group-policy'] = data['intra-group-policy'];
+
+ this.data['consumer-named-selector'] = data['consumer-named-selector'];
+ this.data['provider-named-selector'] = data['provider-named-selector'];
+ this.data['consumer-target-selector'] = data['consumer-target-selector'];
+ this.data['provider-target-selector'] = data['provider-target-selector'];
+
+ this.data['network-domain'] = data['network-domain'];
+ this.data.parent = data.parent;
+
+ this.data.requirement = data.requirement;
+ this.data.capability = data.capability;
+ }
+
+ /**
+ * gets one Epg object from Restconf
+ * @param id
+ * @returns {*}
+ */
+ function get(id, idTenant) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants').one('tenant')
+ .one(idTenant).one('policy').one('endpoint-group').one(this.data.id || id);
+
+ return restObj.get().then(function(data) {
+ self.setData(data['endpoint-group'][0]);
+ });
+ }
+
+ function put(idTenant, successCallback) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants').one('tenant')
+ .one(idTenant).one('policy').one('endpoint-group').one(self.data.id),
+ dataObj = {'endpoint-group': [self.data]};
+
+ return restObj.customPUT(dataObj).then(function(data) {
+ successCallback(data);
+ }, function(res) {
+
+ });
+ }
+
+ function deleteEpg(idTenant, successCallback) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants').one('tenant')
+ .one(idTenant).one('policy').one('endpoint-group').one(self.data.id);
+
+ return restObj.remove().then(function(data) {
+ successCallback(data);
+ }, function(res) {
+
+ });
+ }
+ }
+
+ /**
+ * creates Epg object and fills it with data if available
+ * @param data
+ * @returns {Epg}
+ */
+ function createObject(data) {
+ var obj = new Epg();
+
+ if (data) {
+ obj.setData(data);
+ }
+
+ return obj;
+ }
+ }
+
+ return EpgService;
+});
\ No newline at end of file
+<section flex layout="column">
+ <div flex layout="row">
+ <md-button ng-click="openEpgDialog()" class="md-primary">Add</md-button>
+ <md-button ng-click="getEpgList()" class="md-primary">Reload</md-button>
+ </div>
+ <md-table-container ng-if="epgs.data.length">
+ <table md-table>
+ <thead md-head md-order="epgsTableQuery.order">
+ <tr md-row>
+ <th md-column md-order-by="data.id"><span>Id</span></th>
+ <th md-column md-order-by="data.name"><span>Name</span></th>
+ <th md-column md-order-by="data.description"><span>Description</span></th>
+ <th md-column md-order-by="data['intra-group-policy']"><span>intra-group-policy</span></th>
+ <th md-column md-order-by="data['network-domain']"><span>network-domain</span></th>
+ <th md-column md-order-by="data.parent"><span>Parent</span></th>
+ </tr>
+ </thead>
+ <tbody md-body>
+ <tr md-row ng-repeat="epg in epgs.data | filter: epgsTableQuery.filter | orderBy : epgsTableQuery.order | limitTo: epgsTableQuery.limit : (epgsTableQuery.page -1) * epgsTableQuery.limit">
+ <td md-cell>{{epg.data.id}}</td>
+ <td md-cell>{{epg.data.name}}</td>
+ <td md-cell>{{epg.data.description}}</td>
+ <td md-cell>{{epg.data['intra-group-policy']}}</td>
+ <td md-cell>{{epg.data['network-domain']}}</td>
+ <td md-cell>{{epg.data.parent}}</td>
+ <td md-cell>
+ <md-button class="md-icon-button" ng-click="openEpgDialog(epg)">
+ <md-icon>edit</md-icon>
+ </md-button>
+ <md-button class="md-icon-button" ng-click="deleteEpgDialog(epg)">
+ <md-icon>delete</md-icon>
+ </md-button>
+ </td>
+ </tr>
+
+ </tbody>
+ </table>
+ <md-table-pagination md-limit="epgsTableQuery.limit"
+ md-page="epgsTableQuery.page"
+ md-options="epgsTableQuery.options"
+ md-total="{{epgs.data.length}}"
+ md-page-select="options.pageSelect">
+ </md-table-pagination>
+ </md-table-container>
+</section>
\ No newline at end of file
angular.module('app.gbp').controller('AddTenantController', AddTenantController);
- AddTenantController.$inject = ['$mdDialog', '$scope', 'TenantService'];
+ AddTenantController.$inject = ['$mdDialog', '$scope', 'TenantService', 'tenant'];
/* @ngInject */
- function AddTenantController($mdDialog, $scope, TenantService) {
+ function AddTenantController($mdDialog, $scope, TenantService, tenant) {
/* properties */
- $scope.tenant = TenantService.createObject();
+ $scope.tenant = tenant ? tenant : TenantService.createObject();
/* methods */
$scope.closeDialog = closeDialog;
$scope.save = save;
-
/* Implementations */
function closeDialog(){
$mdDialog.cancel();
+ $scope.getTenantList();
}
function save() {
}, function(err) {
} );
}
+
}
});
-<md-dialog ng-cloak>
+<md-dialog ng-cloak class="gbpDialogWrapper">
<form name="tenantForm">
<md-toolbar>
<div class="md-toolbar-tools">
<md-input-container flex>
<label>Id</label>
<input name="id" ng-model="tenant.data.id" ng-required="true">
- <div ng-messages="tenantForm.id.$error" md-auto-hide="false">
+ <div ng-messages="tenantForm.id.$error">
<div ng-message="required">Required field</div>
</div>
</md-input-container>
<md-input-container flex>
<label>Name</label>
- <input name="name" ng-model="tenant.data.name" ng-required="true">
- <div ng-messages="tenantForm.name.$error" md-auto-hide="false">
- <div ng-message="required">Required field</div>
+ <input name="name" ng-model="tenant.data.name" ng-pattern="/^[a-zA-Z]([a-zA-Z0-9\\-_.])*$/" ng-required="true">
+ <div ng-messages="tenantForm.name.$error">
+ <div ng-message="required">Required field.</div>
+ <div ng-message="pattern">
+ Invalid pattern.
+ <md-tooltip md-direction="right" style="padding-left: 10px;">Value must match: ^[a-zA-Z]([a-zA-Z0-9\\-_.])*$</md-tooltip>
+ </div>
</div>
</md-input-container>
</div>
/* methods */
$scope.getTenantList = getTenantList;
$scope.openTenantDialog = openTenantDialog;
+ $scope.deleteTenantDialog = deleteTenantDialog;
init();
* fills $scope.tenants array with data from data store
*/
function getTenantList() {
+ $scope.tenants = TenantListService.createList();
$scope.tenants.get('config');
}
getTenantList();
}
- function openTenantDialog() {
+ function openTenantDialog(tenantData) {
$mdDialog.show({
clickOutsideToClose: true,
controller: 'AddTenantController',
parent: angular.element(document.body),
scope: $scope,
locals: {
- //policy: $scope.selectedObjects.policy
+ tenant: tenantData
}
});
}
+ function deleteTenantDialog(tenantData) {
+ var confirm = $mdDialog.confirm()
+ .title('Delete tenant')
+ .textContent('Do you want to delete tenant ' + tenantData.data.name + '?')
+ .ok('Delete')
+ .cancel('Cancel');
+
+ $mdDialog.show(confirm).then(function() {
+ tenantData.deleteTenant(
+ function() {
+ $scope.getTenantList();
+ }
+ );
+ }, function() {
+
+ });
+ }
}
});
this.setData = setData;
this.get = get;
this.put = put;
+ this.deleteTenant = deleteTenant;
/* Implementation */
/**
});
}
+
+ function deleteTenant(successCallback) {
+ var self = this;
+
+ var restObj = Restangular.one('restconf').one('config').one('policy:tenants').one('tenant')
+ .one(self.data.id);
+
+ return restObj.remove().then(function(data) {
+ successCallback(data);
+ }, function(res) {
+
+ });
+ }
}
/**
<td md-cell>{{tenant.data.name}}</td>
<td md-cell>{{tenant.data.description}}</td>
<td md-cell>
- <md-button class="md-icon-button" ng-click="edit(tenant)">
+ <md-button class="md-icon-button" ng-click="openTenantDialog(tenant)">
<md-icon>edit</md-icon>
</md-button>
- <md-button class="md-icon-button" ng-click="delete(tenant)">
+ <md-button class="md-icon-button w85" ng-click="deleteTenantDialog(tenant)">
<md-icon>delete</md-icon>
</md-button>
</td>
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller.model</groupId>
+ <artifactId>model-inventory</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<!-- project build -->
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry;
+import org.opendaylight.groupbasedpolicy.location.resolver.LocationResolver;
+import org.opendaylight.groupbasedpolicy.renderer.RendererManager;
import org.opendaylight.groupbasedpolicy.sf.SubjectFeatureDefinitionProvider;
import org.opendaylight.groupbasedpolicy.sf.SupportedActionDefinitionListener;
import org.opendaylight.groupbasedpolicy.sf.SupportedClassifierDefinitionListener;
private final SubjectFeatureDefinitionProvider sfdp;
private final SupportedClassifierDefinitionListener supportedClassifierDefinitionListener;
private final SupportedActionDefinitionListener supportedActionDefinitionListener;
+ private final LocationResolver locationResolver;
+ private final RendererManager rendererManager;
Instance(DataBroker dataProvider, PolicyValidatorRegistry validatorRegistry) throws TransactionCommitFailedException {
sfdp = new SubjectFeatureDefinitionProvider(dataProvider);
supportedClassifierDefinitionListener = new SupportedClassifierDefinitionListener(dataProvider, validatorRegistry);
supportedActionDefinitionListener = new SupportedActionDefinitionListener(dataProvider);
+ locationResolver = new LocationResolver(dataProvider);
+ rendererManager = new RendererManager(dataProvider);
}
@Override
sfdp.close();
supportedClassifierDefinitionListener.close();
supportedActionDefinitionListener.close();
+ locationResolver.close();
+ rendererManager.close();
}
}
package org.opendaylight.groupbasedpolicy.base_endpoint;
import com.google.common.base.Function;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.api.BaseEndpointRendererAugmentation;
import org.opendaylight.groupbasedpolicy.api.BaseEndpointRendererAugmentationRegistry;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.BaseEndpointService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointReg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnreg;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnreg;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.annotation.Nullable;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Future;
+import javax.annotation.Nullable;
+
public class BaseEndpointRpcRegistry
- implements BaseEndpointService, BaseEndpointRendererAugmentationRegistry, AutoCloseable {
+ implements BaseEndpointService, BaseEndpointRendererAugmentationRegistry, AutoCloseable {
- static final ConcurrentMap<String, BaseEndpointRendererAugmentation> registeredRenderers = new ConcurrentHashMap<>();
+ static final ConcurrentMap<String, BaseEndpointRendererAugmentation> registeredRenderers =
+ new ConcurrentHashMap<>();
private static final Logger LOG = LoggerFactory.getLogger(BaseEndpointRpcRegistry.class);
private final DataBroker dataProvider;
private final BindingAwareBroker.RpcRegistration<BaseEndpointService> rpcRegistration;
};
public BaseEndpointRpcRegistry(DataBroker dataProvider, RpcProviderRegistry rpcRegistry) {
- this.dataProvider = dataProvider;
-
- if (rpcRegistry != null) {
- rpcRegistration = rpcRegistry.addRpcImplementation(BaseEndpointService.class, this);
- LOG.debug("Added Endpoints RPC Implementation Correctly");
- } else {
- rpcRegistration = null;
- }
-
- if (dataProvider != null) {
- InstanceIdentifier<Endpoints> iid = InstanceIdentifier.builder(Endpoints.class).build();
- WriteTransaction t = this.dataProvider.newWriteOnlyTransaction();
- t.put(LogicalDatastoreType.OPERATIONAL, iid, new EndpointsBuilder().build());
- CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();
- Futures.addCallback(f, new FutureCallback<Void>() {
-
- @Override
- public void onFailure(Throwable t) {
- LOG.error("Could not write Endpoints base container", t);
- }
+ Preconditions.checkNotNull(dataProvider);
+ Preconditions.checkNotNull(rpcRegistry);
- @Override
- public void onSuccess(Void result) {
- LOG.info("Endpoints container write successful");
- }
- });
- }
+ this.dataProvider = dataProvider;
+ this.rpcRegistration = rpcRegistry.addRpcImplementation(BaseEndpointService.class, this);
}
/**
public void register(BaseEndpointRendererAugmentation baseEndpointRendererAugmentation) {
if (baseEndpointRendererAugmentation != null) {
registeredRenderers.putIfAbsent(baseEndpointRendererAugmentation.getClass().getName(),
- baseEndpointRendererAugmentation);
+ baseEndpointRendererAugmentation);
LOG.info("Registered {}", baseEndpointRendererAugmentation.getClass().getName());
}
}
WriteTransaction t = dataProvider.newWriteOnlyTransaction();
List<ContainmentEndpointReg> endpoints = input.getContainmentEndpointReg();
- for (ContainmentEndpointReg ce : nullToEmpty(endpoints)) {
- long stamp = (ce.getTimestamp() == null || ce.getTimestamp() == 0) ? timestamp : ce.getTimestamp();
- ContainmentEndpoint endpoint = buildContainmentEndpoint(ce).setTimestamp(stamp).build();
- t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(endpoint.getKey()), endpoint,
- true);
- }
+ ListenableFuture<RpcResult<Void>> failResult = verifyRegisterEndpointInput(input);
+ if (failResult == null) {
+ for (ContainmentEndpointReg ce : nullToEmpty(endpoints)) {
+ long stamp = (ce.getTimestamp() == null || ce.getTimestamp() == 0) ? timestamp : ce.getTimestamp();
+ ContainmentEndpoint endpoint = buildContainmentEndpoint(ce).setTimestamp(stamp).build();
+ t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(endpoint.getKey()), endpoint,
+ true);
+
+ updateContainmentEndpointRegChilds(t, endpoint);
+ }
+
+ List<AddressEndpointReg> addressEndpoints = input.getAddressEndpointReg();
+ for (AddressEndpointReg ae : nullToEmpty(addressEndpoints)) {
+ long stamp = (ae.getTimestamp() == null || ae.getTimestamp() == 0) ? timestamp : ae.getTimestamp();
+ AddressEndpoint endpoint = buildAddressEndpoint(ae).setTimestamp(stamp).build();
+ t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(endpoint.getKey()), endpoint,
+ true);
+
+ updateAddressEndpointRegChilds(t, endpoint);
- List<AddressEndpointReg> addressEndpoints = input.getAddressEndpointReg();
- for (AddressEndpointReg ae : nullToEmpty(addressEndpoints)) {
- long stamp = (ae.getTimestamp() == null || ae.getTimestamp() == 0) ? timestamp : ae.getTimestamp();
- AddressEndpoint endpoint = buildAddressEndpoint(ae).setTimestamp(stamp).build();
- t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(endpoint.getKey()), endpoint, true);
+ updateAddressEndpointRegParents(t, endpoint);
+ }
+ } else {
+ return failResult;
}
ListenableFuture<Void> r = t.submit();
return Futures.transform(r, futureTrans);
}
+ private void updateContainmentEndpointRegChilds(WriteTransaction t, ContainmentEndpoint containmentEndpoint) {
+ ReadOnlyTransaction readTransaction = dataProvider.newReadOnlyTransaction();
+
+ for (ChildEndpoint child : nullToEmpty(containmentEndpoint.getChildEndpoint())) {
+ AddressEndpointKey key = new AddressEndpointKey(child.getAddress(), child.getAddressType(),
+ child.getContextId(), child.getContextType());
+ Optional<AddressEndpoint> addressEndpointOptional = DataStoreHelper
+ .readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(key), readTransaction);
+
+ if (addressEndpointOptional.isPresent()) {
+ ParentEndpointChoice parentEndpointChoice = addressEndpointOptional.get().getParentEndpointChoice();
+ List<ParentContainmentEndpoint> parentContainmentEndpoints =
+ getParentContainmentEndpoints(parentEndpointChoice);
+
+ ParentContainmentEndpoint parentContainmentEndpoint =
+ new ParentContainmentEndpointBuilder().setContextId(containmentEndpoint.getContextId())
+ .setContextType(containmentEndpoint.getContextType())
+ .build();
+
+ if (!nullToEmpty(parentContainmentEndpoints).contains(parentContainmentEndpoint)) {
+ parentContainmentEndpoints.add(parentContainmentEndpoint);
+ AddressEndpoint updatedAddressEndpoint = new AddressEndpointBuilder(addressEndpointOptional.get())
+ .setParentEndpointChoice(new ParentContainmentEndpointCaseBuilder()
+ .setParentContainmentEndpoint(parentContainmentEndpoints).build())
+ .build();
+
+ t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(key), updatedAddressEndpoint);
+ }
+ }
+ }
+ }
+
+ private ListenableFuture<RpcResult<Void>> verifyRegisterEndpointInput(RegisterEndpointInput input) {
+ ListenableFuture<RpcResult<Void>> result;
+ List<AddressEndpointReg> addressEndpointRegs = nullToEmpty(input.getAddressEndpointReg());
+ List<ContainmentEndpointReg> containmentEndpointRegs = nullToEmpty(input.getContainmentEndpointReg());
+
+ for (AddressEndpointReg addressEndpointReg : nullToEmpty(addressEndpointRegs)) {
+ result = verifyAddressEndpointChilds(addressEndpointRegs, addressEndpointReg);
+ if (result != null) {
+ return result;
+ }
+
+ result = verifyAddressEndpointParents(addressEndpointRegs, addressEndpointReg);
+ if (result != null) {
+ return result;
+ }
+ }
+
+ result = verifyContainmentEndpointChilds(addressEndpointRegs, containmentEndpointRegs);
+ if (result != null) {
+ return result;
+ }
+
+ return null;
+ }
+
+ private ListenableFuture<RpcResult<Void>> verifyContainmentEndpointChilds(
+ List<AddressEndpointReg> addressEndpointRegs, List<ContainmentEndpointReg> containmentEndpointRegs) {
+ for (ContainmentEndpointReg containmentEndpointReg : nullToEmpty(containmentEndpointRegs)) {
+ for (ChildEndpoint childEndpoint : nullToEmpty(containmentEndpointReg.getChildEndpoint())) {
+ AddressEndpointRegKey key = new AddressEndpointRegKey(childEndpoint.getAddress(),
+ childEndpoint.getAddressType(), childEndpoint.getContextId(), childEndpoint.getContextType());
+ AddressEndpointReg addressEndpointRegChild = findAddressEndpointReg(key, addressEndpointRegs);
+ if (addressEndpointRegChild == null) {
+ // todo this can be optimized if we move this to
+ // updateContainmentEndpointRegChilds and verify child in one step with update.
+ Optional<AddressEndpoint> addressEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(),
+ key.getAddressType(), key.getContextId(), key.getContextType())),
+ dataProvider.newReadOnlyTransaction());
+ if (!addressEndpointOptional.isPresent()) {
+ LOG.debug("Child AddressEndpoint {} does not exist in RPC and DS.", childEndpoint);
+ return buildFailFeature(
+ String.format("Child AddressEndpoint %s does not exist in RPC and DS.", childEndpoint));
+ }
+ } else {
+
+ if (!containmentEndpointReg.getKey().equals(new ContainmentEndpointRegKey(
+ addressEndpointRegChild.getContextId(), addressEndpointRegChild.getContextType()))) {
+ LOG.debug(
+ "Child AddressEndpoint {} in ContainmentEndpoint->ChildEndpoints does not contain a valid ContainmentEndpointRegKey.",
+ addressEndpointRegChild);
+ return buildFailFeature(String
+ .format("AddressEndpoint in ContainmentEndpoint->ChildEndpoints does not contain a valid ContainmentEndpointRegKey."
+ + "\nChild element: %s", addressEndpointRegChild));
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ private ListenableFuture<RpcResult<Void>> verifyAddressEndpointParents(List<AddressEndpointReg> addressEndpointRegs,
+ AddressEndpointReg addressEndpointReg) {
+ ParentEndpointChoice parentEndpointChoice = addressEndpointReg.getParentEndpointChoice();
+ List<ParentEndpoint> parentEndpoints;
+ parentEndpoints =
+ (parentEndpointChoice instanceof ParentEndpointCase) ? ((ParentEndpointCase) parentEndpointChoice)
+ .getParentEndpoint() : null;
+
+ for (ParentEndpoint parentEndpoint : nullToEmpty(parentEndpoints)) {
+ AddressEndpointRegKey key = new AddressEndpointRegKey(parentEndpoint.getAddress(),
+ parentEndpoint.getAddressType(), parentEndpoint.getContextId(), parentEndpoint.getContextType());
+ AddressEndpointReg addressEndpointRegParent = findAddressEndpointReg(key, addressEndpointRegs);
+
+ if (addressEndpointRegParent == null) {
+ // todo this can be optimized if we move this to updateAddressEndpointRegParents and
+ // verify child in one step with update.
+ Optional<AddressEndpoint> addressEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(),
+ key.getAddressType(), key.getContextId(), key.getContextType())),
+ dataProvider.newReadOnlyTransaction());
+ if (!addressEndpointOptional.isPresent()) {
+ LOG.debug("Parent AddressEndpoint {} does not exist in RPC and DS.", parentEndpoint);
+ return buildFailFeature(
+ String.format("Parent AddressEndpoint %s does not exist in RPC and DS.", parentEndpoint));
+ }
+ } else {
+
+ List<ChildEndpoint> childEndpoints = addressEndpointRegParent.getChildEndpoint();
+
+ if (!nullToEmpty(childEndpoints).contains(new ChildEndpointBuilder(addressEndpointReg).build())) {
+ LOG.debug("Parent AddressEndpoint {} does not contain a valid child AddressEndpoint.",
+ addressEndpointRegParent);
+ return buildFailFeature(String.format(
+ "Parent AddressEndpoint does not contain a valid child AddressEndpoint."
+ + "\nParent AddressEndpoint: %s" + "\nChild AddressEndpoint: %s",
+ addressEndpointRegParent, addressEndpointReg));
+ }
+ }
+ }
+ return null;
+ }
+
+ private ListenableFuture<RpcResult<Void>> verifyAddressEndpointChilds(List<AddressEndpointReg> addressEndpointRegs,
+ AddressEndpointReg addressEndpointReg) {
+ for (ChildEndpoint childEndpoint : nullToEmpty(addressEndpointReg.getChildEndpoint())) {
+ AddressEndpointRegKey key = new AddressEndpointRegKey(childEndpoint.getAddress(),
+ childEndpoint.getAddressType(), childEndpoint.getContextId(), childEndpoint.getContextType());
+ AddressEndpointReg addressEndpointRegChild = findAddressEndpointReg(key, addressEndpointRegs);
+ if (addressEndpointRegChild == null) {
+ // todo this can be optimized if we move this to updateAddressEndpointRegChilds and
+ // verify child in one step with update.
+ Optional<AddressEndpoint> addressEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(key.getAddress(),
+ key.getAddressType(), key.getContextId(), key.getContextType())),
+ dataProvider.newReadOnlyTransaction());
+ if (!addressEndpointOptional.isPresent()) {
+ LOG.debug("Child AddressEndpoint {} does not exist in RPC and DS.", childEndpoint);
+ return buildFailFeature(
+ String.format("Child AddressEndpoint %s does not exist in RPC and DS.", childEndpoint));
+ }
+ } else {
+
+ ParentEndpointChoice parentEndpointChoice = addressEndpointRegChild.getParentEndpointChoice();
+
+ if (!(parentEndpointChoice instanceof ParentEndpointCase)) {
+ LOG.debug("Child AddressEndpoint {} does not contain list of parent elements.", childEndpoint);
+ return buildFailFeature(String.format(
+ "Child AddressEndpoint does not contain list of parent elements." + "\nChild element: %s",
+ childEndpoint));
+ }
+
+ List<ParentEndpoint> parentEndpoints =
+ nullToEmpty(((ParentEndpointCase) parentEndpointChoice).getParentEndpoint());
+ if (!parentEndpoints.contains(new ParentEndpointBuilder(addressEndpointReg).build())) {
+ LOG.debug("Child AddressEndpoint {} does not contain a valid parent AddressEndpoint.",
+ addressEndpointRegChild);
+ return buildFailFeature(String.format(
+ "Child AddressEndpoint does not contain a valid parent AddressEndpoint."
+ + "\nChild element: %s" + "\nparent AddressEndpoint: %s",
+ addressEndpointRegChild, addressEndpointReg));
+ }
+ }
+ }
+ return null;
+ }
+
+ private AddressEndpointReg findAddressEndpointReg(AddressEndpointRegKey key, List<AddressEndpointReg> addressEndpointRegs) {
+ for (AddressEndpointReg addressEndpointReg : addressEndpointRegs) {
+ if (addressEndpointReg.getKey().equals(key)) {
+ return addressEndpointReg;
+ }
+ }
+ return null;
+ }
+
+ private void updateAddressEndpointRegParents(WriteTransaction t, AddressEndpoint endpoint) {
+ ParentEndpointCase parentEndpointCase = (ParentEndpointCase) endpoint.getParentEndpointChoice();
+ List<ParentEndpoint> parentEndpoints;
+ ReadOnlyTransaction readTransaction = dataProvider.newReadOnlyTransaction();
+
+ parentEndpoints = getParentEndpoints(parentEndpointCase);
+
+ for (ParentEndpoint parent : nullToEmpty(parentEndpoints)) {
+ Optional<AddressEndpoint> addressEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(parent.getAddress(),
+ parent.getAddressType(), parent.getContextId(), parent.getContextType())),
+ readTransaction);
+
+ if (addressEndpointOptional.isPresent()) {
+
+ List<ChildEndpoint> childEndpoints;
+
+ childEndpoints = (addressEndpointOptional.get() == null || addressEndpointOptional.get()
+ .getChildEndpoint() == null) ? new ArrayList<>() : addressEndpointOptional.get().getChildEndpoint();
+
+ ChildEndpoint childEndpoint = new ChildEndpointBuilder(endpoint).build();
+ if (!childEndpoints.contains(childEndpoint)) {
+ childEndpoints.add(childEndpoint);
+ AddressEndpoint parentAddressEndpoint = new AddressEndpointBuilder(addressEndpointOptional.get())
+ .setChildEndpoint(childEndpoints).build();
+ t.put(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(parentAddressEndpoint.getKey()), parentAddressEndpoint);
+ }
+ }
+ }
+ }
+
+ private void updateAddressEndpointRegChilds(WriteTransaction t, AddressEndpoint endpoint) {
+ ReadTransaction readTransaction = dataProvider.newReadOnlyTransaction();
+
+ for (ChildEndpoint child : nullToEmpty(endpoint.getChildEndpoint())) {
+ Optional<AddressEndpoint> addressEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(child.getAddress(),
+ child.getAddressType(), child.getContextId(), child.getContextType())),
+ readTransaction);
+
+ if (addressEndpointOptional.isPresent()) {
+ ParentEndpointCase parentEndpointCase =
+ (ParentEndpointCase) addressEndpointOptional.get().getParentEndpointChoice();
+ List<ParentEndpoint> parentEndpoints;
+
+ parentEndpoints = getParentEndpoints(parentEndpointCase);
+
+ ParentEndpoint parentEndpoint = new ParentEndpointBuilder(endpoint).build();
+ if (!parentEndpoints.contains(parentEndpoint)) {
+ parentEndpoints.add(parentEndpoint);
+ AddressEndpoint childAddressEndpoint =
+ new AddressEndpointBuilder(addressEndpointOptional.get())
+ .setParentEndpointChoice(
+ new ParentEndpointCaseBuilder().setParentEndpoint(parentEndpoints).build())
+ .build();
+ t.put(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(childAddressEndpoint.getKey()), childAddressEndpoint);
+ }
+ }
+ }
+ }
+
private ContainmentEndpointBuilder buildContainmentEndpoint(ContainmentEndpointReg input) {
+
ContainmentEndpointBuilder eb = new ContainmentEndpointBuilder().setChildEndpoint(input.getChildEndpoint())
.setCondition(input.getCondition())
.setContextType(input.getContextType())
.setKey(new ContainmentEndpointKey(input.getContextId(), input.getContextType()))
.setNetworkContainment(input.getNetworkContainment())
.setTenant(input.getTenant())
- .setTimestamp(input.getTimestamp());
+ .setTimestamp(input.getTimestamp())
+ .setChildEndpoint(input.getChildEndpoint());
for (Map.Entry<String, BaseEndpointRendererAugmentation> entry : registeredRenderers.entrySet()) {
try {
AddressEndpointKey key = new AddressEndpointKey(ae.getAddress(), ae.getAddressType(), ae.getContextId(),
ae.getContextType());
t.delete(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(key));
+
+ updateAddressEndpointUnregChilds(t, ae);
+
+ updateAddressEndpointUnregParents(t, ae);
}
List<ContainmentEndpointUnreg> endpoints = input.getContainmentEndpointUnreg();
for (ContainmentEndpointUnreg ce : nullToEmpty(endpoints)) {
ContainmentEndpointKey key = new ContainmentEndpointKey(ce.getContextId(), ce.getContextType());
t.delete(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(key));
+
+ updateContainmentEndpointUnregChilds(t, ce);
}
ListenableFuture<Void> r = t.submit();
return Futures.transform(r, futureTrans);
}
+ private void updateAddressEndpointUnregParents(WriteTransaction t, AddressEndpointUnreg ae) {
+ ReadTransaction readTransaction = dataProvider.newReadOnlyTransaction();
+
+ Optional<AddressEndpoint> addressEndpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(ae.getAddress(), ae.getAddressType(),
+ ae.getContextId(), ae.getContextType())),
+ readTransaction);
+
+ if (addressEndpointOptional.isPresent()) {
+ ParentEndpointCase parentEndpointCase =
+ (ParentEndpointCase) addressEndpointOptional.get().getParentEndpointChoice();
+ List<ParentEndpoint> parentEndpoints;
+
+ parentEndpoints = getParentEndpoints(parentEndpointCase);
+
+ for (ParentEndpoint parentEndpoint : parentEndpoints) {
+ Optional<AddressEndpoint> parentAddressEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(parentEndpoint.getAddress(),
+ parentEndpoint.getAddressType(), parentEndpoint.getContextId(),
+ parentEndpoint.getContextType())),
+ readTransaction);
+
+ AddressEndpoint parent =
+ parentAddressEndpointOptional.isPresent() ? parentAddressEndpointOptional.get() : null;
+
+ ChildEndpoint endpointToRemove = new ChildEndpointBuilder(addressEndpointOptional.get()).build();
+
+ if (parent != null && nullToEmpty(parent.getChildEndpoint()).contains(endpointToRemove)) {
+ parent.getChildEndpoint().remove(endpointToRemove);
+ t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(parent.getKey()), parent);
+ }
+
+ }
+ }
+ }
+
+ private void updateAddressEndpointUnregChilds(WriteTransaction t, AddressEndpointUnreg ae) {
+ ReadTransaction readTransaction = dataProvider.newReadOnlyTransaction();
+
+ Optional<AddressEndpoint> addressEndpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(ae.getAddress(), ae.getAddressType(),
+ ae.getContextId(), ae.getContextType())),
+ readTransaction);
+
+ if (addressEndpointOptional.isPresent()) {
+ AddressEndpoint endpoint = addressEndpointOptional.get();
+ List<ChildEndpoint> childEndpoints = endpoint.getChildEndpoint();
+
+ for (ChildEndpoint childEndpoint : nullToEmpty(childEndpoints)) {
+ Optional<AddressEndpoint> childAddressEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(new AddressEndpointKey(childEndpoint.getAddress(),
+ childEndpoint.getAddressType(), childEndpoint.getContextId(),
+ childEndpoint.getContextType())),
+ readTransaction);
+
+ AddressEndpoint child =
+ childAddressEndpointOptional.isPresent() ? childAddressEndpointOptional.get() : null;
+ ParentEndpointCase parentEndpointCase =
+ (child != null) ? (ParentEndpointCase) child.getParentEndpointChoice() : null;
+ List<ParentEndpoint> parentEndpoints;
+
+ parentEndpoints = getParentEndpoints(parentEndpointCase);
+
+ ParentEndpoint endpointToRemove = new ParentEndpointBuilder(endpoint).build();
+
+ if (child != null && nullToEmpty(parentEndpoints).contains(endpointToRemove)) {
+ parentEndpoints.remove(endpointToRemove);
+ AddressEndpoint newChild =
+ new AddressEndpointBuilder(child)
+ .setParentEndpointChoice(
+ new ParentEndpointCaseBuilder().setParentEndpoint(parentEndpoints).build())
+ .build();
+
+ t.put(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(newChild.getKey()), newChild);
+ }
+ }
+ }
+ }
+
+ private void updateContainmentEndpointUnregChilds(WriteTransaction t,
+ ContainmentEndpointUnreg containmentEndpointUnreg) {
+ ReadOnlyTransaction readTransaction = dataProvider.newReadOnlyTransaction();
+
+ ContainmentEndpointKey key = new ContainmentEndpointKey(containmentEndpointUnreg.getContextId(),
+ containmentEndpointUnreg.getContextType());
+ Optional<ContainmentEndpoint> containmentEndpointOptional = DataStoreHelper
+ .readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(key), readTransaction);
+
+ if (!containmentEndpointOptional.isPresent()) {
+ return;
+ }
+
+ for (ChildEndpoint child : nullToEmpty(containmentEndpointOptional.get().getChildEndpoint())) {
+ AddressEndpointKey aeKey = new AddressEndpointKey(child.getAddress(), child.getAddressType(),
+ child.getContextId(), child.getContextType());
+ Optional<AddressEndpoint> addressEndpointOptional = DataStoreHelper
+ .readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.addressEndpointIid(aeKey), readTransaction);
+
+ if (addressEndpointOptional.isPresent()) {
+ ParentEndpointChoice parentEndpointChoice = addressEndpointOptional.get().getParentEndpointChoice();
+ List<ParentContainmentEndpoint> parentContainmentEndpoints;
+ parentContainmentEndpoints = getParentContainmentEndpoints(parentEndpointChoice);
+
+ ParentContainmentEndpoint parentContainmentEndpoint =
+ new ParentContainmentEndpointBuilder().setContextId(containmentEndpointUnreg.getContextId())
+ .setContextType(containmentEndpointUnreg.getContextType())
+ .build();
+ if (nullToEmpty(parentContainmentEndpoints).contains(parentContainmentEndpoint)) {
+ t.delete(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.parentContainmentEndpointIid(aeKey, parentContainmentEndpoint.getKey()));
+ }
+ }
+ }
+ }
+
+ private List<ParentContainmentEndpoint> getParentContainmentEndpoints(ParentEndpointChoice parentEndpointChoice) {
+ return (parentEndpointChoice instanceof ParentContainmentEndpointCase) ? ((ParentContainmentEndpointCase) parentEndpointChoice)
+ .getParentContainmentEndpoint() : new ArrayList<>();
+ }
+
+ private List<ParentEndpoint> getParentEndpoints(ParentEndpointCase parentEndpointCase) {
+ return (parentEndpointCase == null
+ || parentEndpointCase.getParentEndpoint() == null) ? new ArrayList<>() : parentEndpointCase
+ .getParentEndpoint();
+ }
+
+ private ListenableFuture<RpcResult<Void>> buildFailFeature(String message) {
+ return Futures
+ .immediateFuture(RpcResultBuilder.<Void>failed().withError(RpcError.ErrorType.PROTOCOL, message).build());
+ }
+
@Override
public void close() throws Exception {
if (rpcRegistration != null) {
*/\r
package org.opendaylight.groupbasedpolicy.dto;\r
\r
-\r
import javax.annotation.Nonnull;\r
\r
import org.opendaylight.groupbasedpolicy.api.ValidationResult;\r
\r
public final class ValidationResultBuilder implements Builder<ValidationResult> {\r
\r
+ public static final String ILLEGAL_ARG_EX_MSG = "Result message cannot be set to NULL!";\r
+\r
private static final class ValidationResultImpl implements ValidationResult {\r
\r
private final boolean success;\r
*/\r
public ValidationResultBuilder setMessage(@Nonnull String message) {\r
if (message == null) {\r
- throw new IllegalArgumentException("Result message cannot be set to NULL!");\r
+ throw new IllegalArgumentException(ILLEGAL_ARG_EX_MSG);\r
}\r
this.message = message;\r
return this;\r
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.location.resolver;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.ExternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderContainmentEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderContainmentEndpointLocationKey;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LocationResolver implements DataTreeChangeListener<LocationProvider>, AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(LocationResolver.class);
+ private Map<AddressEndpointLocationKey, Map<Long, AbsoluteLocation>> realLocations;
+ private DataBroker dataBroker;
+ private ListenerRegistration<LocationResolver> listenerRegistation;
+
+ public LocationResolver(DataBroker dataBroker) {
+ this.dataBroker = dataBroker;
+ this.realLocations = new HashMap<>();
+ this.listenerRegistation = dataBroker.registerDataTreeChangeListener(
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(LocationProviders.class).child(LocationProvider.class).build()),
+ this);
+ }
+
+ @Override
+ public synchronized void onDataTreeChanged(Collection<DataTreeModification<LocationProvider>> changes) {
+ for (DataTreeModification<LocationProvider> change : changes) {
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ switch (change.getRootNode().getModificationType()) {
+ case DELETE: {
+ processRemovedLocationProviderData(change.getRootNode().getDataBefore(), wtx);
+ LOG.debug("Data from location provider {} has been removed",
+ change.getRootNode().getDataBefore().getProvider().getValue());
+ break;
+ }
+ case WRITE: {
+ if (change.getRootNode().getDataBefore() != null) {
+ processRemovedLocationProviderData(change.getRootNode().getDataBefore(), wtx);
+ }
+ processCreatedLocationProviderData(change.getRootNode().getDataAfter(), wtx);
+ LOG.debug("Data from location provider {} has been created",
+ change.getRootNode().getDataAfter().getProvider().getValue());
+ break;
+ }
+ case SUBTREE_MODIFIED: {
+ processRemovedLocationProviderData(change.getRootNode().getDataBefore(), wtx);
+ processCreatedLocationProviderData(change.getRootNode().getDataAfter(), wtx);
+ LOG.debug("Data from location provider {} has been changed",
+ change.getRootNode().getDataAfter().getProvider().getValue());
+ break;
+ }
+ }
+ wtx.submit();
+ }
+ }
+
+ private void processRemovedLocationProviderData(LocationProvider provider, WriteTransaction wtx) {
+ for (ProviderAddressEndpointLocation addressEndpointLocation : nullToEmpty(
+ provider.getProviderAddressEndpointLocation())) {
+ AddressEndpointLocationKey epKey = createAddressEndpointLocationKey(addressEndpointLocation.getKey());
+ long priority;
+ if (provider.getPriority() == null) {
+ priority = 0;
+ LOG.debug("{} provider doesn't provide priority. Using 0 as priority instead.",
+ provider.getProvider().getValue());
+ } else {
+ priority = provider.getPriority();
+ }
+ realLocations.get(epKey).remove(priority);
+ AbsoluteLocation newAbsoluteLocation = getBestAbsoluteLocation(epKey);
+ if (newAbsoluteLocation == null) {
+ InstanceIdentifier<AbsoluteLocation> iid = IidFactory.absoluteLocationIid(epKey);
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ } else {
+ AddressEndpointLocationBuilder newEP =
+ new AddressEndpointLocationBuilder().setKey(epKey).setAbsoluteLocation(newAbsoluteLocation);
+ InstanceIdentifier<AddressEndpointLocation> iid = IidFactory.addressEndpointLocationIid(newEP.getKey());
+ wtx.merge(LogicalDatastoreType.OPERATIONAL, iid, newEP.build(), true);
+ }
+ if (addressEndpointLocation.getRelativeLocations() != null) {
+ for (InternalLocation location : nullToEmpty(
+ addressEndpointLocation.getRelativeLocations().getInternalLocation())) {
+ InstanceIdentifier<InternalLocation> iid = IidFactory.internalLocationIid(epKey, location.getKey());
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ }
+ for (ExternalLocation location : nullToEmpty(
+ addressEndpointLocation.getRelativeLocations().getExternalLocation())) {
+ InstanceIdentifier<ExternalLocation> iid = IidFactory.externalLocationIid(epKey, location.getKey());
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ }
+ }
+ }
+ for (ProviderContainmentEndpointLocation containmentEndpoint : nullToEmpty(
+ provider.getProviderContainmentEndpointLocation())) {
+ ContainmentEndpointLocationKey epKey = createContainmentEndpointLocationKey(containmentEndpoint.getKey());
+ if (containmentEndpoint.getRelativeLocations() != null) {
+ for (InternalLocation location : nullToEmpty(
+ containmentEndpoint.getRelativeLocations().getInternalLocation())) {
+ InstanceIdentifier<InternalLocation> iid = IidFactory.internalLocationIid(epKey, location.getKey());
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ }
+ for (ExternalLocation location : nullToEmpty(
+ containmentEndpoint.getRelativeLocations().getExternalLocation())) {
+ InstanceIdentifier<ExternalLocation> iid = IidFactory.externalLocationIid(epKey, location.getKey());
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ }
+ }
+ }
+ }
+
+ private void processCreatedLocationProviderData(LocationProvider provider, WriteTransaction wtx) {
+ for (ProviderAddressEndpointLocation addressEndpointLocation : nullToEmpty(
+ provider.getProviderAddressEndpointLocation())) {
+ AddressEndpointLocationKey epKey = createAddressEndpointLocationKey(addressEndpointLocation.getKey());
+ AddressEndpointLocationBuilder newEP = new AddressEndpointLocationBuilder().setKey(epKey);
+ if (addressEndpointLocation.getAbsoluteLocation() != null) {
+ if (realLocations.get(epKey) == null) {
+ realLocations.put(epKey, new HashMap<>());
+ }
+ long priority;
+ if (provider.getPriority() == null) {
+ priority = 0;
+ LOG.debug("{} provider doesnt provide priority. Using 0 as priority instead.",
+ provider.getProvider().getValue());
+ } else {
+ priority = provider.getPriority();
+ }
+ realLocations.get(epKey).put(priority, addressEndpointLocation.getAbsoluteLocation());
+ }
+ AbsoluteLocation bestLocation = getBestAbsoluteLocation(epKey);
+ if (bestLocation != null) {
+ newEP.setAbsoluteLocation(bestLocation);
+ }
+ if (addressEndpointLocation.getRelativeLocations() != null) {
+ newEP.setRelativeLocations(addressEndpointLocation.getRelativeLocations());
+ }
+ InstanceIdentifier<AddressEndpointLocation> iid = IidFactory.addressEndpointLocationIid(newEP.getKey());
+ wtx.merge(LogicalDatastoreType.OPERATIONAL, iid, newEP.build(), true);
+ }
+ for (ProviderContainmentEndpointLocation containmentEndpointLocation : nullToEmpty(
+ provider.getProviderContainmentEndpointLocation())) {
+ if (containmentEndpointLocation.getRelativeLocations() != null) {
+ ContainmentEndpointLocationKey key =
+ createContainmentEndpointLocationKey(containmentEndpointLocation.getKey());
+ ContainmentEndpointLocationBuilder newEP = new ContainmentEndpointLocationBuilder().setKey(key);
+ newEP.setRelativeLocations(containmentEndpointLocation.getRelativeLocations());
+ InstanceIdentifier<ContainmentEndpointLocation> iid =
+ IidFactory.containmentEndpointLocationIid(newEP.getKey());
+ wtx.merge(LogicalDatastoreType.OPERATIONAL, iid, newEP.build(), true);
+ }
+ }
+ }
+
+ private AbsoluteLocation getBestAbsoluteLocation(AddressEndpointLocationKey epKey) {
+ if (realLocations.get(epKey) == null) {
+ return null;
+ }
+ long bestPriority = -1;
+ for (long priority : realLocations.get(epKey).keySet()) {
+ bestPriority = bestPriority > priority ? bestPriority : priority;
+ };
+ if (bestPriority == -1) {
+ return null;
+ }
+ return (realLocations.get(epKey).get(new Long(bestPriority)));
+ }
+
+ private AddressEndpointLocationKey createAddressEndpointLocationKey(ProviderAddressEndpointLocationKey key) {
+ return new AddressEndpointLocationKey(key.getAddress(), key.getAddressType(), key.getContextId(),
+ key.getContextType());
+ }
+
+ private ContainmentEndpointLocationKey createContainmentEndpointLocationKey(
+ ProviderContainmentEndpointLocationKey key) {
+ return new ContainmentEndpointLocationKey(key.getContextId(), key.getContextType());
+ }
+
+ private <T> List<T> nullToEmpty(@Nullable List<T> list) {
+ return list == null ? Collections.emptyList() : list;
+ }
+
+ @Override
+ public void close() throws Exception {
+ listenerRegistation.close();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.endpoints.PeerEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.endpoints.PeerExternalEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
+
+public class AddressEndpointUtils {
+
+ public static RendererEndpointKey toRendererEpKey(AddressEndpointKey rendererAdrEpKey) {
+ return new RendererEndpointKey(rendererAdrEpKey.getAddress(), rendererAdrEpKey.getAddressType(),
+ rendererAdrEpKey.getContextId(), rendererAdrEpKey.getContextType());
+ }
+
+ public static PeerEndpointKey toPeerEpKey(AddressEndpointKey peerAdrEpKey) {
+ return new PeerEndpointKey(peerAdrEpKey.getAddress(), peerAdrEpKey.getAddressType(),
+ peerAdrEpKey.getContextId(), peerAdrEpKey.getContextType());
+ }
+
+ public static PeerExternalEndpointKey toPeerExtEpKey(AddressEndpointKey peerAdrEpKey) {
+ return new PeerExternalEndpointKey(peerAdrEpKey.getAddress(), peerAdrEpKey.getAddressType(),
+ peerAdrEpKey.getContextId(), peerAdrEpKey.getContextType());
+ }
+
+ public static AddressEndpointKey fromRendererEpKey(RendererEndpointKey rendererEpKey) {
+ return new AddressEndpointKey(rendererEpKey.getAddress(), rendererEpKey.getAddressType(),
+ rendererEpKey.getContextId(), rendererEpKey.getContextType());
+ }
+
+ public static AddressEndpointKey fromPeerEpKey(PeerEndpointKey peerEpKey) {
+ return new AddressEndpointKey(peerEpKey.getAddress(), peerEpKey.getAddressType(), peerEpKey.getContextId(),
+ peerEpKey.getContextType());
+ }
+
+ public static AddressEndpointKey fromPeerExtEpKey(PeerExternalEndpointKey peerExtEpKey) {
+ return new AddressEndpointKey(peerExtEpKey.getAddress(), peerExtEpKey.getAddressType(),
+ peerExtEpKey.getContextId(), peerExtEpKey.getContextType());
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.containment.endpoints.PeerExternalContainmentEndpointKey;
+
+public class ContainmentEndpointUtils {
+
+ public static PeerExternalContainmentEndpointKey toPeerExtContEpKey(ContainmentEndpointKey peerContEpKey) {
+ return new PeerExternalContainmentEndpointKey(peerContEpKey.getContextId(), peerContEpKey.getContextType());
+ }
+
+ public static ContainmentEndpointKey fromPeerExtContEpKey(PeerExternalContainmentEndpointKey peerExtContEpKey) {
+ return new ContainmentEndpointKey(peerExtContEpKey.getContextId(), peerExtContEpKey.getContextType());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.Set;
+
+import org.opendaylight.groupbasedpolicy.dto.EpgKey;
+import org.opendaylight.groupbasedpolicy.dto.EpgKeyDto;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+import com.google.common.collect.ImmutableSetMultimap;
+
+public class EndpointInfo {
+
+ private final ImmutableMap<AddressEndpointKey, AddressEndpoint> addressEpByKey;
+ private final ImmutableMap<ContainmentEndpointKey, ContainmentEndpoint> containmentEpByKey;
+ private final ImmutableSetMultimap<EpgKey, AddressEndpointKey> addressEpsByEpg;
+ private final ImmutableSetMultimap<EpgKey, ContainmentEndpointKey> containmentEpsByEpg;
+
+ public EndpointInfo(Endpoints endpoints) {
+ if (endpoints.getAddressEndpoints() == null || endpoints.getAddressEndpoints().getAddressEndpoint() == null) {
+ addressEpByKey = ImmutableMap.of();
+ addressEpsByEpg = ImmutableSetMultimap.of();
+ } else {
+ com.google.common.collect.ImmutableMap.Builder<AddressEndpointKey, AddressEndpoint> addressEpsByKeyBuilder =
+ ImmutableMap.builder();
+ com.google.common.collect.ImmutableSetMultimap.Builder<EpgKey, AddressEndpointKey> addressEpsByEpgBuilder =
+ ImmutableSetMultimap.builder();
+ com.google.common.collect.ImmutableMultimap.Builder<Set<EpgKey>, AddressEndpointKey> addressEpsByEpgsBuilder =
+ ImmutableMultimap.builder();
+ for (AddressEndpoint ep : endpoints.getAddressEndpoints().getAddressEndpoint()) {
+ addressEpsByKeyBuilder.put(ep.getKey(), ep);
+ Builder<EpgKey> epgsBuilder = ImmutableSet.builder();
+ for (EndpointGroupId epgId : ep.getEndpointGroup()) {
+ EpgKey epgKey = new EpgKeyDto(epgId, ep.getTenant());
+ addressEpsByEpgBuilder.put(epgKey, ep.getKey());
+ epgsBuilder.add(epgKey);
+ }
+ addressEpsByEpgsBuilder.put(epgsBuilder.build(), ep.getKey());
+ }
+ addressEpByKey = addressEpsByKeyBuilder.build();
+ addressEpsByEpg = addressEpsByEpgBuilder.build();
+ }
+ if (endpoints.getContainmentEndpoints() == null
+ || endpoints.getContainmentEndpoints().getContainmentEndpoint() == null) {
+ containmentEpByKey = ImmutableMap.of();
+ containmentEpsByEpg = ImmutableSetMultimap.of();
+ } else {
+ com.google.common.collect.ImmutableSetMultimap.Builder<EpgKey, ContainmentEndpointKey> containmentEpsByEpgBuilder =
+ ImmutableSetMultimap.builder();
+ com.google.common.collect.ImmutableMap.Builder<ContainmentEndpointKey, ContainmentEndpoint> containmentEpsByKeyBuilder =
+ ImmutableMap.builder();
+ com.google.common.collect.ImmutableMultimap.Builder<Set<EpgKey>, ContainmentEndpointKey> containmentEpsByEpgsBuilder =
+ ImmutableMultimap.builder();
+ for (ContainmentEndpoint ep : endpoints.getContainmentEndpoints().getContainmentEndpoint()) {
+ containmentEpsByKeyBuilder.put(ep.getKey(), ep);
+ Builder<EpgKey> epgsBuilder = ImmutableSet.builder();
+ for (EndpointGroupId epgId : ep.getEndpointGroup()) {
+ EpgKey epgKey = new EpgKeyDto(epgId, ep.getTenant());
+ containmentEpsByEpgBuilder.put(epgKey, ep.getKey());
+ epgsBuilder.add(epgKey);
+ }
+ containmentEpsByEpgsBuilder.put(epgsBuilder.build(), ep.getKey());
+ }
+ containmentEpByKey = containmentEpsByKeyBuilder.build();
+ containmentEpsByEpg = containmentEpsByEpgBuilder.build();
+ }
+ }
+
+ public Optional<AddressEndpoint> getEndpoint(AddressEndpointKey key) {
+ return Optional.fromNullable(addressEpByKey.get(key));
+ }
+
+ public Optional<ContainmentEndpoint> getContainmentEndpoint(ContainmentEndpointKey key) {
+ return Optional.fromNullable(containmentEpByKey.get(key));
+ }
+
+ public ImmutableSet<AddressEndpointKey> findAddressEpsWithEpg(EpgKey epg) {
+ return addressEpsByEpg.get(epg);
+ }
+
+ public ImmutableSet<ContainmentEndpointKey> findContainmentEpsWithEpg(EpgKey epg) {
+ return containmentEpsByEpg.get(epg);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.List;
+import java.util.Set;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.RelativeLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocation;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+
+public class EndpointLocationInfo {
+
+ private final ImmutableMultimap<InstanceIdentifier<?>, AddressEndpointLocation> endpointsByAbsNodeLocation;
+ private final ImmutableMap<AddressEndpointKey, AddressEndpointLocation> adrEpLocByAdrEpKey;
+ private final ImmutableMap<ContainmentEndpointKey, ContainmentEndpointLocation> contEpLocBycontEpKey;
+
+ public EndpointLocationInfo(EndpointLocations epLocations) {
+ List<AddressEndpointLocation> addressEndpointLocations = epLocations.getAddressEndpointLocation();
+ endpointsByAbsNodeLocation = EndpointLocationUtils.resolveEndpointsByAbsoluteNodeLocation(addressEndpointLocations);
+ if (addressEndpointLocations == null) {
+ adrEpLocByAdrEpKey = ImmutableMap.of();
+ } else {
+ com.google.common.collect.ImmutableMap.Builder<AddressEndpointKey, AddressEndpointLocation> adrEpLocByAdrEpKeyBuilder =
+ ImmutableMap.builder();
+ for (AddressEndpointLocation adrEpLoc : addressEndpointLocations) {
+ adrEpLocByAdrEpKeyBuilder.put(toAdrEpKey(adrEpLoc.getKey()), adrEpLoc);
+ }
+ adrEpLocByAdrEpKey = adrEpLocByAdrEpKeyBuilder.build();
+ }
+ List<ContainmentEndpointLocation> containmentEndpointLocations = epLocations.getContainmentEndpointLocation();
+ if (containmentEndpointLocations == null) {
+ contEpLocBycontEpKey = ImmutableMap.of();
+ } else {
+ com.google.common.collect.ImmutableMap.Builder<ContainmentEndpointKey, ContainmentEndpointLocation> contEpLocBycontEpKeyBuilder =
+ ImmutableMap.builder();
+ for (ContainmentEndpointLocation contEpLoc : containmentEndpointLocations) {
+ contEpLocBycontEpKeyBuilder.put(toContEpKey(contEpLoc.getKey()), contEpLoc);
+ }
+ contEpLocBycontEpKey = contEpLocBycontEpKeyBuilder.build();
+ }
+ }
+
+ public Optional<AddressEndpointLocation> getAdressEndpointLocation(AddressEndpointKey epKey) {
+ return Optional.fromNullable(adrEpLocByAdrEpKey.get(epKey));
+ }
+
+ public Optional<ContainmentEndpointLocation> getContainmentEndpointLocation(ContainmentEndpointKey contEpKey) {
+ return Optional.fromNullable(contEpLocBycontEpKey.get(contEpKey));
+ }
+
+ private AddressEndpointKey toAdrEpKey(AddressEndpointLocationKey adrEpLocKey) {
+ return new AddressEndpointKey(adrEpLocKey.getAddress(), adrEpLocKey.getAddressType(),
+ adrEpLocKey.getContextId(), adrEpLocKey.getContextType());
+ }
+
+ private ContainmentEndpointKey toContEpKey(ContainmentEndpointLocationKey contEpLocKey) {
+ return new ContainmentEndpointKey(contEpLocKey.getContextId(), contEpLocKey.getContextType());
+ }
+
+ public Set<InstanceIdentifier<?>> getAllAbsoluteNodeLocations() {
+ return endpointsByAbsNodeLocation.keySet();
+ }
+
+ public ImmutableSet<AddressEndpointKey> getAddressEpsWithAbsoluteNodeLocation(InstanceIdentifier<?> realNodeLocation) {
+ return FluentIterable.from(endpointsByAbsNodeLocation.get(realNodeLocation))
+ .transform(new Function<AddressEndpointLocation, AddressEndpointKey>() {
+
+ @Override
+ public AddressEndpointKey apply(AddressEndpointLocation epLoc) {
+ return new AddressEndpointKey(epLoc.getAddress(),
+ epLoc.getAddressType(), epLoc.getContextId(), epLoc.getContextType());
+ }
+ })
+ .toSet();
+ }
+
+ public boolean hasRealLocation(AddressEndpointKey adrEpKey) {
+ AddressEndpointLocation adrEpLoc = adrEpLocByAdrEpKey.get(adrEpKey);
+ if (adrEpLoc == null) {
+ return false;
+ }
+ AbsoluteLocation absLocation = adrEpLoc.getAbsoluteLocation();
+ if (absLocation == null) {
+ return false;
+ }
+ LocationType locationType = absLocation.getLocationType();
+ if (locationType == null) {
+ return false;
+ }
+ return true;
+ }
+
+ public boolean hasRelativeLocation(AddressEndpointKey adrEpKey) {
+ AddressEndpointLocation adrEpLoc = adrEpLocByAdrEpKey.get(adrEpKey);
+ if (adrEpLoc == null) {
+ return false;
+ }
+ RelativeLocations relLocations = adrEpLoc.getRelativeLocations();
+ if (relLocations == null) {
+ return false;
+ }
+ List<InternalLocation> locs = relLocations.getInternalLocation();
+ if (locs == null) {
+ return false;
+ }
+ return true;
+ }
+
+ public boolean hasRelativeLocation(ContainmentEndpointKey contEpKey) {
+ ContainmentEndpointLocation contEpLoc = contEpLocBycontEpKey.get(contEpKey);
+ if (contEpLoc == null) {
+ return false;
+ }
+ RelativeLocations relLocations = contEpLoc.getRelativeLocations();
+ if (relLocations == null) {
+ return false;
+ }
+ List<InternalLocation> locs = relLocations.getInternalLocation();
+ if (locs == null) {
+ return false;
+ }
+ return true;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCase;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableMultimap.Builder;
+
+public class EndpointLocationUtils {
+
+ public static ImmutableMultimap<InstanceIdentifier<?>, AddressEndpointLocation> resolveEndpointsByAbsoluteNodeLocation(
+ @Nullable List<AddressEndpointLocation> addressEndpointLocations) {
+ if (addressEndpointLocations == null) {
+ return ImmutableMultimap.of();
+ }
+ Builder<InstanceIdentifier<?>, AddressEndpointLocation> resultBuilder = ImmutableMultimap.builder();
+ for (AddressEndpointLocation epLoc : addressEndpointLocations) {
+ Optional<InstanceIdentifier<?>> potentialAbsIntNodeLocation = resolveAbsoluteInternalNodeLocation(epLoc);
+ if (potentialAbsIntNodeLocation.isPresent()) {
+ resultBuilder.put(potentialAbsIntNodeLocation.get(), epLoc);
+ } else {
+ Optional<InstanceIdentifier<?>> potentialAbsExtNodeMpLocation =
+ resolveAbsoluteExternalNodeMountPointLocation(epLoc);
+ if (potentialAbsExtNodeMpLocation.isPresent()) {
+ resultBuilder.put(potentialAbsExtNodeMpLocation.get(), epLoc);
+ }
+ }
+ }
+ return resultBuilder.build();
+ }
+
+ public static Optional<InstanceIdentifier<?>> resolveAbsoluteInternalNodeLocation(AddressEndpointLocation epLoc) {
+ AbsoluteLocation absLoc = epLoc.getAbsoluteLocation();
+ if (absLoc != null) {
+ LocationType locType = absLoc.getLocationType();
+ if (locType instanceof InternalLocationCase) {
+ InternalLocationCase absRegularLoc = (InternalLocationCase) locType;
+ if (absRegularLoc.getInternalNode() != null) {
+ return Optional.of(absRegularLoc.getInternalNode());
+ }
+ }
+ }
+ return Optional.absent();
+ }
+
+ public static Optional<InstanceIdentifier<?>> resolveAbsoluteExternalNodeMountPointLocation(
+ AddressEndpointLocation epLoc) {
+ AbsoluteLocation absLoc = epLoc.getAbsoluteLocation();
+ if (absLoc != null) {
+ LocationType locType = absLoc.getLocationType();
+ if (locType instanceof ExternalLocationCase) {
+ ExternalLocationCase realExtLoc = (ExternalLocationCase) locType;
+ if (realExtLoc.getExternalNodeMountPoint() != null) {
+ return Optional.of(realExtLoc.getExternalNodeMountPoint());
+ }
+ }
+ }
+ return Optional.absent();
+ }
+
+ public static Optional<InstanceIdentifier<?>> resolveAbsoluteNodeLocation(AddressEndpointLocation epLoc) {
+ if (epLoc.getAbsoluteLocation() == null) {
+ return Optional.absent();
+ }
+ LocationType locType = epLoc.getAbsoluteLocation().getLocationType();
+ if (locType instanceof InternalLocationCase) {
+ InternalLocationCase absLoc = (InternalLocationCase) locType;
+ if (absLoc.getInternalNode() != null) {
+ return Optional.of(absLoc.getInternalNode());
+ }
+ } else if (locType instanceof ExternalLocationCase) {
+ ExternalLocationCase absLoc = (ExternalLocationCase) locType;
+ if (absLoc.getExternalNodeMountPoint() != null) {
+ return Optional.of(absLoc.getExternalNodeMountPoint());
+ }
+ }
+ return Optional.absent();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.endpoints.PeerEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.containment.endpoints.PeerExternalContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.endpoints.PeerExternalEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.EndpointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContexts;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContextsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroupsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.forwarding.contexts.ForwardingContextByTenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.forwarding.contexts.ForwardingContextByTenantBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointWithPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointWithPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointWithPolicyKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalContainmentEndpointWithPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalContainmentEndpointWithPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalContainmentEndpointWithPolicyKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicyKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableTable;
+import com.google.common.collect.Table;
+
+public class RendererConfigurationBuilder {
+
+ private final Table<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerEp =
+ HashBasedTable.create();
+ private final Table<RendererEndpointKey, PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerExtEp =
+ HashBasedTable.create();
+ private final Table<RendererEndpointKey, PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerExtCtxEp =
+ HashBasedTable.create();
+ private final Set<AddressEndpointKey> adrEpKeys = new HashSet<>();
+ private final Set<ContainmentEndpointKey> contEpKeys = new HashSet<>();
+ private final Set<PolicyRuleGroupKey> policyRuleGrpKeys = new HashSet<>();
+
+ public void add(RendererEndpointKey rendererEpKey, PeerEndpointKey peerEpKey, PolicyRuleGroupKey ruleGrpKey,
+ EndpointPolicyParticipation rendererEpParticipation) {
+ Set<RuleGroupWithRendererEndpointParticipation> ruleGrpWithRendererEpParticipation =
+ policiesByEpAndPeerEp.get(rendererEpKey, peerEpKey);
+ if (ruleGrpWithRendererEpParticipation == null) {
+ ruleGrpWithRendererEpParticipation = new HashSet<>();
+ policiesByEpAndPeerEp.put(rendererEpKey, peerEpKey, ruleGrpWithRendererEpParticipation);
+ adrEpKeys.add(AddressEndpointUtils.fromRendererEpKey(rendererEpKey));
+ adrEpKeys.add(AddressEndpointUtils.fromPeerEpKey(peerEpKey));
+ }
+ policyRuleGrpKeys.add(ruleGrpKey);
+ ruleGrpWithRendererEpParticipation
+ .add(toRuleGroupWithRendererEndpointParticipation(ruleGrpKey, rendererEpParticipation));
+ }
+
+ public void add(RendererEndpointKey rendererEpKey, PeerExternalEndpointKey peerExtEpKey,
+ PolicyRuleGroupKey ruleGrpKey, EndpointPolicyParticipation rendererEpParticipation) {
+ Set<RuleGroupWithRendererEndpointParticipation> ruleGrpWithRendererEpParticipation =
+ policiesByEpAndPeerExtEp.get(rendererEpKey, peerExtEpKey);
+ if (ruleGrpWithRendererEpParticipation == null) {
+ ruleGrpWithRendererEpParticipation = new HashSet<>();
+ policiesByEpAndPeerExtEp.put(rendererEpKey, peerExtEpKey, ruleGrpWithRendererEpParticipation);
+ adrEpKeys.add(AddressEndpointUtils.fromRendererEpKey(rendererEpKey));
+ adrEpKeys.add(AddressEndpointUtils.fromPeerExtEpKey(peerExtEpKey));
+ }
+ policyRuleGrpKeys.add(ruleGrpKey);
+ ruleGrpWithRendererEpParticipation
+ .add(toRuleGroupWithRendererEndpointParticipation(ruleGrpKey, rendererEpParticipation));
+ }
+
+ public void add(RendererEndpointKey rendererEpKey, PeerExternalContainmentEndpointKey peerExtContainmentEpKey,
+ PolicyRuleGroupKey ruleGrpKey, EndpointPolicyParticipation rendererEpParticipation) {
+ Set<RuleGroupWithRendererEndpointParticipation> ruleGrpWithRendererEpParticipation =
+ policiesByEpAndPeerExtCtxEp.get(rendererEpKey, peerExtContainmentEpKey);
+ if (ruleGrpWithRendererEpParticipation == null) {
+ ruleGrpWithRendererEpParticipation = new HashSet<>();
+ policiesByEpAndPeerExtCtxEp.put(rendererEpKey, peerExtContainmentEpKey, ruleGrpWithRendererEpParticipation);
+ adrEpKeys.add(AddressEndpointUtils.fromRendererEpKey(rendererEpKey));
+ contEpKeys.add(ContainmentEndpointUtils.fromPeerExtContEpKey(peerExtContainmentEpKey));
+ }
+ policyRuleGrpKeys.add(ruleGrpKey);
+ ruleGrpWithRendererEpParticipation
+ .add(toRuleGroupWithRendererEndpointParticipation(ruleGrpKey, rendererEpParticipation));
+ }
+
+ public static RuleGroupWithRendererEndpointParticipation toRuleGroupWithRendererEndpointParticipation(
+ PolicyRuleGroupKey ruleGrpKey, EndpointPolicyParticipation rendererEpParticipation) {
+ return new RuleGroupWithRendererEndpointParticipationBuilder().setTenantId(ruleGrpKey.getTenantId())
+ .setContractId(ruleGrpKey.getContractId())
+ .setSubjectName(ruleGrpKey.getSubjectName())
+ .setRendererEndpointParticipation(rendererEpParticipation)
+ .build();
+ }
+
+ public ImmutableTable<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> getPoliciesByEpAndPeerEp() {
+ return ImmutableTable.copyOf(policiesByEpAndPeerEp);
+ }
+
+ public ImmutableTable<RendererEndpointKey, PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> getPoliciesByEpAndPeerExtEp() {
+ return ImmutableTable.copyOf(policiesByEpAndPeerExtEp);
+ }
+
+ public ImmutableTable<RendererEndpointKey, PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> getPoliciesByEpAndPeerExtConEp() {
+ return ImmutableTable.copyOf(policiesByEpAndPeerExtCtxEp);
+ }
+
+ public ImmutableSet<AddressEndpointKey> getAddressEndpointKeys() {
+ return ImmutableSet.copyOf(adrEpKeys);
+ }
+
+ public ImmutableSet<ContainmentEndpointKey> getContainmentEndpointKeys() {
+ return ImmutableSet.copyOf(contEpKeys);
+ }
+
+ public ImmutableSet<PolicyRuleGroupKey> getPolicyRuleGroupKeys() {
+ return ImmutableSet.copyOf(policyRuleGrpKeys);
+ }
+
+ public @Nonnull RendererEndpoints buildRendererEndpoints() {
+ Map<RendererEndpointKey, RendererEndpointBuilder> rendererEpBuilderByKey = new HashMap<>();
+ for (RendererEndpointKey rendererEpKey : policiesByEpAndPeerEp.rowKeySet()) {
+ RendererEndpointBuilder rendererEpBuilder =
+ resolveRendererEndpointBuilder(rendererEpKey, rendererEpBuilderByKey);
+ List<PeerEndpointWithPolicy> peerEpsWithPolicy =
+ toListPeerEndpointWithPolicy(policiesByEpAndPeerEp.row(rendererEpKey));
+ rendererEpBuilder.setPeerEndpointWithPolicy(peerEpsWithPolicy);
+ rendererEpBuilderByKey.put(rendererEpKey, rendererEpBuilder);
+ }
+ for (RendererEndpointKey rendererEpKey : policiesByEpAndPeerExtEp.rowKeySet()) {
+ RendererEndpointBuilder rendererEpBuilder =
+ resolveRendererEndpointBuilder(rendererEpKey, rendererEpBuilderByKey);
+ List<PeerExternalEndpointWithPolicy> peerExtEpsWithPolicy =
+ toListPeerExternalEndpointWithPolicy(policiesByEpAndPeerExtEp.row(rendererEpKey));
+ rendererEpBuilder.setPeerExternalEndpointWithPolicy(peerExtEpsWithPolicy);
+ rendererEpBuilderByKey.put(rendererEpKey, rendererEpBuilder);
+ }
+ for (RendererEndpointKey rendererEpKey : policiesByEpAndPeerExtCtxEp.rowKeySet()) {
+ RendererEndpointBuilder rendererEpBuilder =
+ resolveRendererEndpointBuilder(rendererEpKey, rendererEpBuilderByKey);
+ List<PeerExternalContainmentEndpointWithPolicy> peerExtContEpsWithPolicy =
+ toListPeerExternalContainmentEndpointWithPolicy(policiesByEpAndPeerExtCtxEp.row(rendererEpKey));
+ rendererEpBuilder.setPeerExternalContainmentEndpointWithPolicy(peerExtContEpsWithPolicy);
+ rendererEpBuilderByKey.put(rendererEpKey, rendererEpBuilder);
+ }
+ List<RendererEndpoint> rendererEps = new ArrayList<>();
+ for (RendererEndpointBuilder builder : rendererEpBuilderByKey.values()) {
+ rendererEps.add(builder.build());
+ }
+ return new RendererEndpointsBuilder().setRendererEndpoint(rendererEps).build();
+ }
+
+ private static RendererEndpointBuilder resolveRendererEndpointBuilder(RendererEndpointKey rendererEpKey,
+ Map<RendererEndpointKey, RendererEndpointBuilder> rendererEpBuilderByKey) {
+ RendererEndpointBuilder rendererEpBuilder = rendererEpBuilderByKey.get(rendererEpKey);
+ if (rendererEpBuilder == null) {
+ rendererEpBuilder = new RendererEndpointBuilder();
+ rendererEpBuilder.setKey(rendererEpKey);
+ }
+ return rendererEpBuilder;
+ }
+
+ private static List<PeerEndpointWithPolicy> toListPeerEndpointWithPolicy(
+ Map<PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByPeerEp) {
+ List<PeerEndpointWithPolicy> peerEpsWithPolicy = new ArrayList<>();
+ for (Entry<PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> entry : policiesByPeerEp
+ .entrySet()) {
+ PeerEndpointKey peerEpKey = entry.getKey();
+ PeerEndpointWithPolicyKey peerEndpointWithPolicyKey = new PeerEndpointWithPolicyKey(peerEpKey.getAddress(),
+ peerEpKey.getAddressType(), peerEpKey.getContextId(), peerEpKey.getContextType());
+ PeerEndpointWithPolicy peerEndpointWithPolicy =
+ new PeerEndpointWithPolicyBuilder().setKey(peerEndpointWithPolicyKey)
+ .setRuleGroupWithRendererEndpointParticipation(new ArrayList<>(entry.getValue()))
+ .build();
+ peerEpsWithPolicy.add(peerEndpointWithPolicy);
+ }
+ return peerEpsWithPolicy;
+ }
+
+ private static List<PeerExternalEndpointWithPolicy> toListPeerExternalEndpointWithPolicy(
+ Map<PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByPeerExtEp) {
+ List<PeerExternalEndpointWithPolicy> peerExtEpsWithPolicy = new ArrayList<>();
+ for (Entry<PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> entry : policiesByPeerExtEp
+ .entrySet()) {
+ PeerExternalEndpointKey peerEpKey = entry.getKey();
+ PeerExternalEndpointWithPolicyKey peerExternalEpWithPolicyKey =
+ new PeerExternalEndpointWithPolicyKey(peerEpKey.getAddress(), peerEpKey.getAddressType(),
+ peerEpKey.getContextId(), peerEpKey.getContextType());
+ PeerExternalEndpointWithPolicy peerExternalEpWithPolicy =
+ new PeerExternalEndpointWithPolicyBuilder().setKey(peerExternalEpWithPolicyKey)
+ .setRuleGroupWithRendererEndpointParticipation(new ArrayList<>(entry.getValue()))
+ .build();
+ peerExtEpsWithPolicy.add(peerExternalEpWithPolicy);
+ }
+ return peerExtEpsWithPolicy;
+ }
+
+ private static List<PeerExternalContainmentEndpointWithPolicy> toListPeerExternalContainmentEndpointWithPolicy(
+ Map<PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByPeerExtContEp) {
+ List<PeerExternalContainmentEndpointWithPolicy> peerExtContEpsWithPolicy = new ArrayList<>();
+ for (Entry<PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> entry : policiesByPeerExtContEp
+ .entrySet()) {
+ PeerExternalContainmentEndpointKey peerEpKey = entry.getKey();
+ PeerExternalContainmentEndpointWithPolicyKey peerExternalContEpWithPolicyKey =
+ new PeerExternalContainmentEndpointWithPolicyKey(peerEpKey.getContextId(),
+ peerEpKey.getContextType());
+ PeerExternalContainmentEndpointWithPolicy peerExternalContEpWithPolicy =
+ new PeerExternalContainmentEndpointWithPolicyBuilder().setKey(peerExternalContEpWithPolicyKey)
+ .setRuleGroupWithRendererEndpointParticipation(new ArrayList<>(entry.getValue()))
+ .build();
+ peerExtContEpsWithPolicy.add(peerExternalContEpWithPolicy);
+ }
+ return peerExtContEpsWithPolicy;
+ }
+
+ public Endpoints buildEndoints(EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
+ Map<InstanceIdentifier<?>, RendererName> rendererByNode) {
+ List<AddressEndpointWithLocation> epsWithLoc =
+ resolveEpsWithLoc(getAddressEndpointKeys(), epInfo, epLocInfo, rendererByNode);
+ List<ContainmentEndpointWithLocation> contEpsWithLoc =
+ resolveContEpsWithLoc(getContainmentEndpointKeys(), epInfo, epLocInfo);
+ return new EndpointsBuilder().setAddressEndpointWithLocation(epsWithLoc)
+ .setContainmentEndpointWithLocation(contEpsWithLoc)
+ .build();
+ }
+
+ private static List<AddressEndpointWithLocation> resolveEpsWithLoc(Set<AddressEndpointKey> epKeys,
+ EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
+ Map<InstanceIdentifier<?>, RendererName> rendererByNode) {
+ List<AddressEndpointWithLocation> result = new ArrayList<>();
+ for (AddressEndpointKey epKey : epKeys) {
+ Optional<AddressEndpoint> potentialEp = epInfo.getEndpoint(epKey);
+ Preconditions.checkArgument(potentialEp.isPresent());
+ Optional<AddressEndpointLocation> potentionalEpLoc = epLocInfo.getAdressEndpointLocation(epKey);
+ Preconditions.checkArgument(potentionalEpLoc.isPresent());
+ RendererName rendererName = resolveRendererName(potentionalEpLoc.get(), rendererByNode);
+ result.add(createEpWithLoc(potentialEp.get(), potentionalEpLoc.get(), rendererName));
+ }
+ return result;
+ }
+
+ private static RendererName resolveRendererName(AddressEndpointLocation epLoc,
+ Map<InstanceIdentifier<?>, RendererName> rendererByNode) {
+ Optional<InstanceIdentifier<?>> potentialAbsNodeLoc = EndpointLocationUtils.resolveAbsoluteNodeLocation(epLoc);
+ if (potentialAbsNodeLoc.isPresent()) {
+ return rendererByNode.get(potentialAbsNodeLoc.get());
+ }
+ return null;
+ }
+
+ private static AddressEndpointWithLocation createEpWithLoc(AddressEndpoint ep, AddressEndpointLocation epLoc,
+ RendererName rendererName) {
+ return new AddressEndpointWithLocationBuilder().setAddress(ep.getAddress())
+ .setAddressType(ep.getAddressType())
+ .setContextId(ep.getContextId())
+ .setContextType(ep.getContextType())
+ .setTenant(ep.getTenant())
+ .setChildEndpoint(ep.getChildEndpoint())
+ .setParentEndpointChoice(ep.getParentEndpointChoice())
+ .setEndpointGroup(ep.getEndpointGroup())
+ .setCondition(ep.getCondition())
+ .setNetworkContainment(ep.getNetworkContainment())
+ .setTimestamp(ep.getTimestamp())
+ .setAbsoluteLocation(epLoc.getAbsoluteLocation())
+ .setRelativeLocations(epLoc.getRelativeLocations())
+ .setRendererName(rendererName)
+ .build();
+ }
+
+ private static List<ContainmentEndpointWithLocation> resolveContEpsWithLoc(Set<ContainmentEndpointKey> contEpKeys,
+ EndpointInfo epInfo, EndpointLocationInfo epLocInfo) {
+ List<ContainmentEndpointWithLocation> result = new ArrayList<>();
+ for (ContainmentEndpointKey contEpKey : contEpKeys) {
+ Optional<ContainmentEndpoint> potentialContEp = epInfo.getContainmentEndpoint(contEpKey);
+ Preconditions.checkArgument(potentialContEp.isPresent());
+ Optional<ContainmentEndpointLocation> potentialContEpLoc =
+ epLocInfo.getContainmentEndpointLocation(contEpKey);
+ Preconditions.checkArgument(potentialContEpLoc.isPresent());
+ result.add(createContEpWithLoc(potentialContEp.get(), potentialContEpLoc.get()));
+ }
+ return result;
+ }
+
+ private static ContainmentEndpointWithLocation createContEpWithLoc(ContainmentEndpoint contEp,
+ ContainmentEndpointLocation contEpLoc) {
+ return new ContainmentEndpointWithLocationBuilder().setContextId(contEp.getContextId())
+ .setContextType(contEp.getContextType())
+ .setTenant(contEp.getTenant())
+ .setChildEndpoint(contEp.getChildEndpoint())
+ .setEndpointGroup(contEp.getEndpointGroup())
+ .setCondition(contEp.getCondition())
+ .setNetworkContainment(contEp.getNetworkContainment())
+ .setTimestamp(contEp.getTimestamp())
+ .setRelativeLocations(contEpLoc.getRelativeLocations())
+ .build();
+ }
+
+ public RuleGroups buildRuluGroups(ResolvedPolicyInfo policyInfo) {
+ List<RuleGroup> ruleGroups = resolveRuleGroups(getPolicyRuleGroupKeys(), policyInfo);
+ return new RuleGroupsBuilder().setRuleGroup(ruleGroups).build();
+ }
+
+ private List<RuleGroup> resolveRuleGroups(Set<PolicyRuleGroupKey> policyRuleGrpKeys,
+ ResolvedPolicyInfo policyInfo) {
+ List<RuleGroup> result = new ArrayList<>();
+ for (PolicyRuleGroupKey policyRuleGrpKey : policyRuleGrpKeys) {
+ Optional<PolicyRuleGroup> potentialPolicyRuleGrp = policyInfo.getPolicyRuleGroup(policyRuleGrpKey);
+ Preconditions.checkArgument(potentialPolicyRuleGrp.isPresent());
+ result.add(createRuleGroup(potentialPolicyRuleGrp.get()));
+ }
+ return result;
+ }
+
+ private RuleGroup createRuleGroup(PolicyRuleGroup policyRuleGrp) {
+ return new RuleGroupBuilder().setTenantId(policyRuleGrp.getTenantId())
+ .setContractId(policyRuleGrp.getContractId())
+ .setSubjectName(policyRuleGrp.getSubjectName())
+ .setResolvedRule(policyRuleGrp.getResolvedRule())
+ .setOrder(policyRuleGrp.getOrder())
+ .build();
+ }
+
+ // TODO this copies entire Forwarding to ForwardingContexts - it could copy only forwarding used
+ // in EPs (renderer EPs + peers)
+ public ForwardingContexts buildForwardingContexts(Forwarding forwarding) {
+ List<ForwardingContextByTenant> forwardingContextByTenant =
+ resolveForwardingContextByTenant(forwarding.getForwardingByTenant());
+ return new ForwardingContextsBuilder().setForwardingContextByTenant(forwardingContextByTenant).build();
+ }
+
+ private static List<ForwardingContextByTenant> resolveForwardingContextByTenant(
+ List<ForwardingByTenant> forwardingByTenant) {
+ List<ForwardingContextByTenant> result = new ArrayList<>();
+ for (ForwardingByTenant fwdByTenant : forwardingByTenant) {
+ result.add(new ForwardingContextByTenantBuilder(fwdByTenant).build());
+ }
+ return result;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.dto.ConsEpgKey;
+import org.opendaylight.groupbasedpolicy.dto.EpgKeyDto;
+import org.opendaylight.groupbasedpolicy.dto.ProvEpgKey;
+import org.opendaylight.groupbasedpolicy.renderer.listener.EndpointLocationsListener;
+import org.opendaylight.groupbasedpolicy.renderer.listener.EndpointsListener;
+import org.opendaylight.groupbasedpolicy.renderer.listener.ForwardingListener;
+import org.opendaylight.groupbasedpolicy.renderer.listener.RenderersListener;
+import org.opendaylight.groupbasedpolicy.renderer.listener.ResolvedPoliciesListener;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RenderersBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.endpoints.PeerEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.containment.endpoints.PeerExternalContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.endpoints.PeerExternalEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.ConfigurationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Status;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContexts;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy.ExternalImplicitGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+
+public class RendererManager implements AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(RendererManager.class);
+
+ private static long version = 0;
+
+ private final DataBroker dataProvider;
+ private final Set<RendererName> processingRenderers = new HashSet<>();
+ private Map<InstanceIdentifier<?>, RendererName> rendererByNode = new HashMap<>();
+ private ResolvedPolicyInfo policyInfo;
+ private EndpointInfo epInfo;
+ private EndpointLocationInfo epLocInfo;
+ private Forwarding forwarding;
+
+ private final EndpointsListener endpointsListener;
+ private final EndpointLocationsListener endpointLocationsListener;
+ private final ResolvedPoliciesListener resolvedPoliciesListener;
+ private final ForwardingListener forwardingListener;
+ private final RenderersListener renderersListener;
+
+ public RendererManager(DataBroker dataProvider) {
+ this.dataProvider = checkNotNull(dataProvider);
+ endpointsListener = new EndpointsListener(this, dataProvider);
+ endpointLocationsListener = new EndpointLocationsListener(this, dataProvider);
+ resolvedPoliciesListener = new ResolvedPoliciesListener(this, dataProvider);
+ forwardingListener = new ForwardingListener(this, dataProvider);
+ renderersListener = new RenderersListener(this, dataProvider);
+ }
+
+ public synchronized void endpointsUpdated(final Endpoints endpoints) {
+ epInfo = new EndpointInfo(endpoints);
+ processState();
+ }
+
+ public synchronized void endpointLocationsUpdated(final EndpointLocations epLocations) {
+ epLocInfo = new EndpointLocationInfo(epLocations);
+ processState();
+ }
+
+ public synchronized void resolvedPoliciesUpdated(final ResolvedPolicies resolvedPolicies) {
+ policyInfo = new ResolvedPolicyInfo(resolvedPolicies);
+ processState();
+ }
+
+ public synchronized void forwardingUpdated(final Forwarding forwarding) {
+ this.forwarding = forwarding;
+ processState();
+ }
+
+ public synchronized void renderersUpdated(final Renderers renderersCont) {
+ ImmutableMultimap<InstanceIdentifier<?>, RendererName> renderersByNode =
+ RendererUtils.resolveRenderersByNodes(renderersCont.getRenderer());
+ rendererByNode = new HashMap<>();
+ for (InstanceIdentifier<?> nodePath : renderersByNode.keySet()) {
+ ImmutableCollection<RendererName> renderers = renderersByNode.get(nodePath);
+ // only first renderer is used
+ rendererByNode.put(nodePath, renderers.asList().get(0));
+ }
+ if (processingRenderers.isEmpty()) {
+ processState();
+ } else {
+ LOG.debug("Waiting for renderers. Version {} needs to be processed by renderers: {}", version,
+ processingRenderers);
+ ImmutableMap<RendererName, Renderer> rendererByName =
+ RendererUtils.resolveRendererByName(renderersCont.getRenderer());
+ for (RendererName configuredRenderer : processingRenderers) {
+ Renderer renderer = rendererByName.get(configuredRenderer);
+ RendererPolicy rendererPolicy = renderer.getRendererPolicy();
+ if (rendererPolicy != null && rendererPolicy.getVersion() != null
+ && renderer.getRendererPolicy().getVersion().equals(version)) {
+ processingRenderers.remove(configuredRenderer);
+ Status status = rendererPolicy.getStatus();
+ if (status != null && status.getUnconfiguredRule() != null) {
+ LOG.warn("Renderer {} did not configure policy with version {} successfully. \n{}",
+ configuredRenderer.getValue(), version, status);
+ } else {
+ LOG.debug("Renderer {} configured policy with version {} successfully.",
+ configuredRenderer.getValue(), version);
+ }
+ }
+ }
+ }
+ }
+
+ private void processState() {
+ if (!processingRenderers.isEmpty()) {
+ LOG.debug("Waiting for renderers. Version {} needs to be processed by renderers: {}", version,
+ processingRenderers);
+ return;
+ }
+ if (rendererByNode.values().isEmpty()) {
+ return;
+ }
+
+ version++;
+ Map<RendererName, RendererConfigurationBuilder> rendererConfigBuilderByRendererName = createRendererConfigBuilders();
+ List<Renderer> renderers = new ArrayList<>();
+ Set<RendererName> rendererNames = new HashSet<>(rendererByNode.values());
+ for (RendererName rendererName : rendererNames) {
+ RendererConfigurationBuilder rendererPolicyBuilder = rendererConfigBuilderByRendererName.get(rendererName);
+ Optional<Configuration> potentialConfig = createConfiguration(rendererPolicyBuilder);
+ RendererPolicy rendererPolicy = null;
+ if (potentialConfig.isPresent()) {
+ LOG.debug("Created configuration for renderer with version {}", rendererName.getValue(), version);
+ rendererPolicy =
+ new RendererPolicyBuilder().setVersion(version).setConfiguration(potentialConfig.get()).build();
+ } else {
+ rendererPolicy =
+ new RendererPolicyBuilder().setVersion(version).build();
+ }
+ renderers.add(new RendererBuilder().setName(rendererName).setRendererPolicy(rendererPolicy).build());
+ processingRenderers.add(rendererName);
+ }
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Renderers.class),
+ new RenderersBuilder().setRenderer(renderers).build());
+ if (!DataStoreHelper.submitToDs(wTx)) {
+ LOG.warn("Version {} was not dispatched successfully. Previous version is valid till next update.",
+ version);
+ for (RendererName rendererName : rendererConfigBuilderByRendererName.keySet()) {
+ processingRenderers.remove(rendererName);
+ }
+ version--;
+ }
+ }
+
+ /**
+ * Entry is added to the result map only if:<br>
+ * 1. There is at least one Address EP with absolute location
+ * 2. There is a renderer responsible for that EP
+ *
+ * @return
+ */
+ private Map<RendererName, RendererConfigurationBuilder> createRendererConfigBuilders() {
+ if (!isStateValid()) {
+ return Collections.emptyMap();
+ }
+ Map<RendererName, RendererConfigurationBuilder> rendererConfigBuilderByRendererName = new HashMap<>();
+ for (InstanceIdentifier<?> absEpLocation : epLocInfo.getAllAbsoluteNodeLocations()) {
+ RendererName rendererName = rendererByNode.get(absEpLocation);
+ if (rendererName == null) {
+ LOG.trace("Renderer does not exist for EP with location: {}", absEpLocation);
+ continue;
+ }
+ RendererConfigurationBuilder rendererConfigBuilder = rendererConfigBuilderByRendererName.get(rendererName);
+ if (rendererConfigBuilder == null) {
+ rendererConfigBuilder = new RendererConfigurationBuilder();
+ rendererConfigBuilderByRendererName.put(rendererName, rendererConfigBuilder);
+ }
+ for (AddressEndpointKey rendererAdrEpKey : epLocInfo.getAddressEpsWithAbsoluteNodeLocation(absEpLocation)) {
+ Optional<AddressEndpoint> potentialAddressEp = epInfo.getEndpoint(rendererAdrEpKey);
+ if (!potentialAddressEp.isPresent()) {
+ LOG.trace("Endpoint does not exist but has location: {}", rendererAdrEpKey);
+ continue;
+ }
+ AddressEndpoint rendererAdrEp = potentialAddressEp.get();
+ resolveRendererConfigForEndpoint(rendererAdrEp, rendererConfigBuilder);
+ }
+ }
+ return rendererConfigBuilderByRendererName;
+ }
+
+ private boolean isStateValid() {
+ if (rendererByNode.isEmpty() || policyInfo == null || epInfo == null || epLocInfo == null
+ || forwarding == null) {
+ return false;
+ }
+ return true;
+ }
+
+ private Optional<Configuration> createConfiguration(@Nullable RendererConfigurationBuilder rendererPolicyBuilder) {
+ if (rendererPolicyBuilder == null) {
+ return Optional.absent();
+ }
+ ConfigurationBuilder configBuilder = new ConfigurationBuilder();
+ RendererEndpoints rendererEndpoints = rendererPolicyBuilder.buildRendererEndpoints();
+ if (isRendererEndpointsEmpty(rendererEndpoints)) {
+ return Optional.absent();
+ }
+ configBuilder.setRendererEndpoints(rendererEndpoints);
+
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints endpoints =
+ rendererPolicyBuilder.buildEndoints(epInfo, epLocInfo, rendererByNode);
+ configBuilder.setEndpoints(endpoints);
+
+ RuleGroups ruleGroups = rendererPolicyBuilder.buildRuluGroups(policyInfo);
+ configBuilder.setRuleGroups(ruleGroups);
+
+ ForwardingContexts forwardingContexts = rendererPolicyBuilder.buildForwardingContexts(forwarding);
+ configBuilder.setForwardingContexts(forwardingContexts);
+
+ return Optional.of(configBuilder.build());
+ }
+
+ private boolean isRendererEndpointsEmpty(RendererEndpoints rendererEndpoints) {
+ if (rendererEndpoints == null || rendererEndpoints.getRendererEndpoint() == null
+ || rendererEndpoints.getRendererEndpoint().isEmpty()) {
+ return true;
+ }
+ return false;
+ }
+
+ @VisibleForTesting
+ void resolveRendererConfigForEndpoint(AddressEndpoint rendererAdrEp,
+ RendererConfigurationBuilder rendererPolicyBuilder) {
+ Set<EpgKeyDto> rendererEpgs = toEpgKeys(rendererAdrEp.getEndpointGroup(), rendererAdrEp.getTenant());
+ RendererEndpointKey rendererEpKey = AddressEndpointUtils.toRendererEpKey(rendererAdrEp.getKey());
+ for (EpgKeyDto rendererEpg : rendererEpgs) {
+ ImmutableSet<ConsEpgKey> consPeerEpgs = policyInfo.findConsumerPeers(rendererEpg);
+ for (ConsEpgKey consPeerEpg : consPeerEpgs) {
+ Optional<ResolvedPolicy> potentialPolicy = policyInfo.findPolicy(consPeerEpg, rendererEpg);
+ ResolvedPolicy policy = potentialPolicy.get();
+ ImmutableSet<AddressEndpointKey> consPeerAdrEps = epInfo.findAddressEpsWithEpg(consPeerEpg);
+ resolveRendererPolicyBetweenEpAndPeers(rendererEpKey, consPeerAdrEps, policy,
+ EndpointPolicyParticipation.PROVIDER, rendererPolicyBuilder);
+ ImmutableSet<ContainmentEndpointKey> consPeerContEps = epInfo.findContainmentEpsWithEpg(consPeerEpg);
+ resolveRendererPolicyBetweenEpAndContPeers(rendererEpKey, consPeerContEps, policy,
+ EndpointPolicyParticipation.PROVIDER, rendererPolicyBuilder);
+ }
+ ImmutableSet<ProvEpgKey> provPeerEpgs = policyInfo.findProviderPeers(rendererEpg);
+ for (ProvEpgKey provPeerEpg : provPeerEpgs) {
+ Optional<ResolvedPolicy> potentialPolicy = policyInfo.findPolicy(rendererEpg, provPeerEpg);
+ ResolvedPolicy policy = potentialPolicy.get();
+ ImmutableSet<AddressEndpointKey> provPeerAdrEps = epInfo.findAddressEpsWithEpg(provPeerEpg);
+ resolveRendererPolicyBetweenEpAndPeers(rendererEpKey, provPeerAdrEps, policy,
+ EndpointPolicyParticipation.CONSUMER, rendererPolicyBuilder);
+ ImmutableSet<ContainmentEndpointKey> provPeerContEps = epInfo.findContainmentEpsWithEpg(provPeerEpg);
+ resolveRendererPolicyBetweenEpAndContPeers(rendererEpKey, provPeerContEps, policy,
+ EndpointPolicyParticipation.CONSUMER, rendererPolicyBuilder);
+ }
+ }
+ }
+
+ private void resolveRendererPolicyBetweenEpAndContPeers(RendererEndpointKey rendererEpKey,
+ Set<ContainmentEndpointKey> peerContEps, ResolvedPolicy policy,
+ EndpointPolicyParticipation rendererEpParticipation, RendererConfigurationBuilder rendererPolicyBuilder) {
+ if (isRendererEpInEig(policy, rendererEpParticipation)) {
+ LOG.info("Renderer EP cannot be in EIG therefore it is ignored: {}. \nPolicy: {}", rendererEpKey);
+ LOG.debug("Renderer EP participation: {}, Policy: {}", rendererEpParticipation, policy);
+ return;
+ }
+ for (ContainmentEndpointKey peerContEpKey : peerContEps) {
+ ExternalImplicitGroup eig = policy.getExternalImplicitGroup();
+ if (eig != null) { // peers are in EIG
+ if (!epLocInfo.hasRelativeLocation(peerContEpKey)) {
+ LOG.debug("EIG Containment Peer does not have relative location therefore it is ignored: {}",
+ peerContEpKey);
+ continue;
+ }
+ PeerExternalContainmentEndpointKey peerExtContEpKey =
+ ContainmentEndpointUtils.toPeerExtContEpKey(peerContEpKey);
+ for (PolicyRuleGroupWithEndpointConstraints ruleGrpsWithEpConstraints : policy
+ .getPolicyRuleGroupWithEndpointConstraints()) {
+ // TODO filter based on endpoint constraints
+ for (PolicyRuleGroup ruleGrp : ruleGrpsWithEpConstraints.getPolicyRuleGroup()) {
+ rendererPolicyBuilder.add(rendererEpKey, peerExtContEpKey, ruleGrp.getKey(),
+ rendererEpParticipation);
+ }
+ }
+ } else {
+ LOG.info("Peer Containment EP cannot be in other EPG than EIG therefore it is ignored: {}",
+ peerContEpKey);
+ }
+ }
+ }
+
+ private void resolveRendererPolicyBetweenEpAndPeers(RendererEndpointKey rendererEpKey,
+ Set<AddressEndpointKey> peerAdrEps, ResolvedPolicy policy,
+ EndpointPolicyParticipation rendererEpParticipation, RendererConfigurationBuilder rendererPolicyBuilder) {
+ if (isRendererEpInEig(policy, rendererEpParticipation)) {
+ LOG.info("Renderer EP cannot be in EIG therefore it is ignored: {}. \nPolicy: {}", rendererEpKey);
+ LOG.debug("Renderer EP participation: {}, Policy: {}", rendererEpParticipation, policy);
+ return;
+ }
+ for (AddressEndpointKey peerAdrEpKey : peerAdrEps) {
+ ExternalImplicitGroup eig = policy.getExternalImplicitGroup();
+ if (eig != null) {
+ if (!epLocInfo.hasRelativeLocation(peerAdrEpKey)) {
+ LOG.debug("EIG Peer does not have relative location therefore it is ignored: {}", peerAdrEpKey);
+ continue;
+ }
+ PeerExternalEndpointKey peerExtEpKey = AddressEndpointUtils.toPeerExtEpKey(peerAdrEpKey);
+ for (PolicyRuleGroupWithEndpointConstraints ruleGrpsWithEpConstraints : policy
+ .getPolicyRuleGroupWithEndpointConstraints()) {
+ // TODO filter based on endpoint constraints
+ for (PolicyRuleGroup ruleGrp : ruleGrpsWithEpConstraints.getPolicyRuleGroup()) {
+ rendererPolicyBuilder.add(rendererEpKey, peerExtEpKey, ruleGrp.getKey(),
+ rendererEpParticipation);
+ }
+ }
+ } else {
+ if (!epLocInfo.hasRealLocation(peerAdrEpKey)) {
+ LOG.debug("Peer does not have real location therefore it is ignored: {}", peerAdrEpKey);
+ continue;
+ }
+ PeerEndpointKey peerEpKey = AddressEndpointUtils.toPeerEpKey(peerAdrEpKey);
+ for (PolicyRuleGroupWithEndpointConstraints ruleGrpsWithEpConstraints : policy
+ .getPolicyRuleGroupWithEndpointConstraints()) {
+ // TODO filter based on endpoint constraints
+ for (PolicyRuleGroup ruleGrp : ruleGrpsWithEpConstraints.getPolicyRuleGroup()) {
+ rendererPolicyBuilder.add(rendererEpKey, peerEpKey, ruleGrp.getKey(), rendererEpParticipation);
+ }
+ }
+ }
+ }
+ }
+
+ private boolean isRendererEpInEig(ResolvedPolicy policy, EndpointPolicyParticipation rendererEpParticipation) {
+ ExternalImplicitGroup eig = policy.getExternalImplicitGroup();
+ if (rendererEpParticipation == EndpointPolicyParticipation.PROVIDER
+ && ExternalImplicitGroup.ProviderEpg == eig) {
+ return true;
+ } else if (rendererEpParticipation == EndpointPolicyParticipation.CONSUMER
+ && ExternalImplicitGroup.ConsumerEpg == eig) {
+ return true;
+ }
+ return false;
+ }
+
+ private Set<EpgKeyDto> toEpgKeys(List<EndpointGroupId> epgIds, TenantId tenantId) {
+ return FluentIterable.from(epgIds).transform(new Function<EndpointGroupId, EpgKeyDto>() {
+
+ @Override
+ public EpgKeyDto apply(EndpointGroupId input) {
+ return new EpgKeyDto(input, tenantId);
+ }
+ }).toSet();
+ }
+
+ @VisibleForTesting
+ Set<RendererName> getProcessingRenderers() {
+ return processingRenderers;
+ }
+
+ @VisibleForTesting
+ static void resetVersion() {
+ version = 0;
+ }
+
+ @Override
+ public void close() throws Exception {
+ endpointsListener.close();
+ endpointLocationsListener.close();
+ resolvedPoliciesListener.close();
+ forwardingListener.close();
+ renderersListener.close();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.List;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableMultimap.Builder;
+import com.google.common.collect.Maps;
+
+public class RendererUtils {
+
+ public static @Nonnull ImmutableMultimap<InstanceIdentifier<?>, RendererName> resolveRenderersByNodes(
+ @Nullable List<Renderer> renderers) {
+ if (renderers == null) {
+ return ImmutableMultimap.of();
+ }
+ Builder<InstanceIdentifier<?>, RendererName> renderersByNodeBuilder = ImmutableMultimap.builder();
+ for (Renderer renderer : renderers) {
+ List<RendererNode> rendererNodes = renderer.getRendererNodes().getRendererNode();
+ if (rendererNodes == null) {
+ continue;
+ }
+ for (RendererNode rendererNode : rendererNodes) {
+ if (rendererNode.getNodePath() != null) {
+ renderersByNodeBuilder.put(rendererNode.getNodePath(), renderer.getName());
+ }
+ }
+ }
+ return renderersByNodeBuilder.build();
+ }
+
+ public static @Nonnull ImmutableMap<RendererName, Renderer> resolveRendererByName(
+ @Nullable List<Renderer> renderers) {
+ if (renderers == null) {
+ return ImmutableMap.of();
+ }
+ return Maps.uniqueIndex(renderers, Renderer::getName);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.opendaylight.groupbasedpolicy.dto.ConsEpgKey;
+import org.opendaylight.groupbasedpolicy.dto.EpgKeyDto;
+import org.opendaylight.groupbasedpolicy.dto.ProvEpgKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupKey;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableTable;
+import com.google.common.collect.ImmutableTable.Builder;
+
+public class ResolvedPolicyInfo {
+
+ private final ImmutableTable<ConsEpgKey, ProvEpgKey, ResolvedPolicy> policyByEpgs;
+ private final Map<PolicyRuleGroupKey, PolicyRuleGroup> policyRuleGrpByKey = new HashMap<>();
+
+ public ResolvedPolicyInfo(ResolvedPolicies resolvedPolicies) {
+ if (resolvedPolicies.getResolvedPolicy() == null) {
+ policyByEpgs = ImmutableTable.of();
+ } else {
+ Builder<ConsEpgKey, ProvEpgKey, ResolvedPolicy> policyByEpgsBuilder = new Builder<>();
+ for (ResolvedPolicy resolvedPolicy : resolvedPolicies.getResolvedPolicy()) {
+ policyByEpgsBuilder.put(
+ new EpgKeyDto(resolvedPolicy.getConsumerEpgId(), resolvedPolicy.getConsumerTenantId()),
+ new EpgKeyDto(resolvedPolicy.getProviderEpgId(), resolvedPolicy.getProviderTenantId()),
+ resolvedPolicy);
+ for (PolicyRuleGroupWithEndpointConstraints ruleGrpWithEpConstraints : resolvedPolicy
+ .getPolicyRuleGroupWithEndpointConstraints()) {
+ for (PolicyRuleGroup ruleGrp : ruleGrpWithEpConstraints.getPolicyRuleGroup()) {
+ policyRuleGrpByKey.put(ruleGrp.getKey(), ruleGrp);
+ }
+ }
+ }
+ policyByEpgs = policyByEpgsBuilder.build();
+ }
+ }
+
+ public Optional<PolicyRuleGroup> getPolicyRuleGroup(PolicyRuleGroupKey policyRuleGrpKey) {
+ return Optional.fromNullable(policyRuleGrpByKey.get(policyRuleGrpKey));
+ }
+
+ public ImmutableSet<ProvEpgKey> findProviderPeers(ConsEpgKey consKey) {
+ return policyByEpgs.row(consKey).keySet();
+ }
+
+ public ImmutableSet<ConsEpgKey> findConsumerPeers(ProvEpgKey provKey) {
+ return policyByEpgs.column(provKey).keySet();
+ }
+
+ public Optional<ResolvedPolicy> findPolicy(ConsEpgKey consKey, ProvEpgKey provKey) {
+ return Optional.fromNullable(policyByEpgs.get(consKey, provKey));
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer.listener;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.RendererManager;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class EndpointLocationsListener extends DataTreeChangeHandler<EndpointLocations> implements AutoCloseable {
+
+ private final RendererManager rendererManager;
+
+ public EndpointLocationsListener(RendererManager rendererManager, DataBroker dataProvider) {
+ super(dataProvider);
+ this.rendererManager = rendererManager;
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(EndpointLocations.class)));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<EndpointLocations> rootNode,
+ InstanceIdentifier<EndpointLocations> rootIdentifier) {
+ rendererManager.endpointLocationsUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<EndpointLocations> rootNode,
+ InstanceIdentifier<EndpointLocations> rootIdentifier) {
+ rendererManager.endpointLocationsUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<EndpointLocations> rootNode,
+ InstanceIdentifier<EndpointLocations> rootIdentifier) {
+ rendererManager.endpointLocationsUpdated(rootNode.getDataAfter());
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer.listener;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.RendererManager;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class EndpointsListener extends DataTreeChangeHandler<Endpoints> implements AutoCloseable {
+
+ private final RendererManager rendererManager;
+
+ public EndpointsListener(RendererManager rendererManager, DataBroker dataProvider) {
+ super(dataProvider);
+ this.rendererManager = rendererManager;
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Endpoints.class)));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<Endpoints> rootNode, InstanceIdentifier<Endpoints> rootIdentifier) {
+ rendererManager.endpointsUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<Endpoints> rootNode, InstanceIdentifier<Endpoints> rootIdentifier) {
+ rendererManager.endpointsUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<Endpoints> rootNode,
+ InstanceIdentifier<Endpoints> rootIdentifier) {
+ rendererManager.endpointsUpdated(rootNode.getDataAfter());
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer.listener;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.RendererManager;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class ForwardingListener extends DataTreeChangeHandler<Forwarding> implements AutoCloseable {
+
+ private final RendererManager rendererManager;
+
+ public ForwardingListener(RendererManager rendererManager, DataBroker dataProvider) {
+ super(dataProvider);
+ this.rendererManager = rendererManager;
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(Forwarding.class)));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<Forwarding> rootNode, InstanceIdentifier<Forwarding> rootIdentifier) {
+ rendererManager.forwardingUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<Forwarding> rootNode,
+ InstanceIdentifier<Forwarding> rootIdentifier) {
+ rendererManager.forwardingUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<Forwarding> rootNode,
+ InstanceIdentifier<Forwarding> rootIdentifier) {
+ rendererManager.forwardingUpdated(rootNode.getDataAfter());
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer.listener;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.RendererManager;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class RenderersListener extends DataTreeChangeHandler<Renderers> implements AutoCloseable {
+
+ private final RendererManager rendererManager;
+
+ public RenderersListener(RendererManager rendererManager, DataBroker dataProvider) {
+ super(dataProvider);
+ this.rendererManager = rendererManager;
+ registerDataTreeChangeListener(
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Renderers.class)));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<Renderers> rootNode, InstanceIdentifier<Renderers> rootIdentifier) {
+ rendererManager.renderersUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<Renderers> rootNode, InstanceIdentifier<Renderers> rootIdentifier) {
+ rendererManager.renderersUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<Renderers> rootNode,
+ InstanceIdentifier<Renderers> rootIdentifier) {
+ rendererManager.renderersUpdated(rootNode.getDataAfter());
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer.listener;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.RendererManager;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class ResolvedPoliciesListener extends DataTreeChangeHandler<ResolvedPolicies> implements AutoCloseable {
+
+ private final RendererManager rendererManager;
+
+ public ResolvedPoliciesListener(RendererManager rendererManager, DataBroker dataProvider) {
+ super(dataProvider);
+ this.rendererManager = rendererManager;
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(ResolvedPolicies.class)));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<ResolvedPolicies> rootNode,
+ InstanceIdentifier<ResolvedPolicies> rootIdentifier) {
+ rendererManager.resolvedPoliciesUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<ResolvedPolicies> rootNode,
+ InstanceIdentifier<ResolvedPolicies> rootIdentifier) {
+ rendererManager.resolvedPoliciesUpdated(rootNode.getDataAfter());
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<ResolvedPolicies> rootNode,
+ InstanceIdentifier<ResolvedPolicies> rootIdentifier) {
+ rendererManager.resolvedPoliciesUpdated(rootNode.getDataAfter());
+ }
+
+}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.ContainmentEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.containment.endpoint._case.ParentContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.RelativeLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.ExternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.ExternalLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.statistics.store.rev151215.statistics.store.StatisticRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.statistics.store.rev151215.statistics.store.StatisticRecordKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
public class IidFactory {
.build();
}
- public static InstanceIdentifierBuilder<ProviderAddressEndpointLocation> providerAddressEndpointLocationIid(String provider,
+ public static InstanceIdentifier<ParentContainmentEndpoint> parentContainmentEndpointIid(
+ AddressEndpointKey addressEndpointKey, ParentContainmentEndpointKey parentContainmentEndpointKey) {
+ return InstanceIdentifier
+ .builder(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints.class)
+ .child(AddressEndpoints.class)
+ .child(AddressEndpoint.class, addressEndpointKey)
+ .child(ParentContainmentEndpoint.class, parentContainmentEndpointKey)
+ .build();
+ }
+
+ public static InstanceIdentifier<AddressEndpointLocation> addressEndpointLocationIid(AddressEndpointLocationKey addrEndpointLocationKey) {
+ return InstanceIdentifier.builder(EndpointLocations.class)
+ .child(AddressEndpointLocation.class, addrEndpointLocationKey)
+ .build();
+ }
+
+ public static InstanceIdentifier<ContainmentEndpointLocation> containmentEndpointLocationIid(ContainmentEndpointLocationKey addrEndpointLocationKey) {
+ return InstanceIdentifier.builder(EndpointLocations.class)
+ .child(ContainmentEndpointLocation.class, addrEndpointLocationKey)
+ .build();
+ }
+
+ public static InstanceIdentifier<InternalLocation> internalLocationIid(AddressEndpointLocationKey addrEndpointLocationKey,
+ InternalLocationKey internalLocationKey) {
+ return InstanceIdentifier.builder(EndpointLocations.class)
+ .child(AddressEndpointLocation.class, addrEndpointLocationKey)
+ .child(RelativeLocations.class)
+ .child(InternalLocation.class, internalLocationKey)
+ .build();
+ }
+
+ public static InstanceIdentifier<InternalLocation> internalLocationIid(ContainmentEndpointLocationKey contEndpointLocationKey,
+ InternalLocationKey internalLocationKey) {
+ return InstanceIdentifier.builder(EndpointLocations.class)
+ .child(ContainmentEndpointLocation.class, contEndpointLocationKey)
+ .child(RelativeLocations.class)
+ .child(InternalLocation.class, internalLocationKey)
+ .build();
+ }
+
+ public static InstanceIdentifier<ExternalLocation> externalLocationIid(AddressEndpointLocationKey addrEndpointLocationKey,
+ ExternalLocationKey externalLocationKey) {
+ return InstanceIdentifier.builder(EndpointLocations.class)
+ .child(AddressEndpointLocation.class, addrEndpointLocationKey)
+ .child(RelativeLocations.class)
+ .child(ExternalLocation.class, externalLocationKey)
+ .build();
+ }
+
+ public static InstanceIdentifier<ExternalLocation> externalLocationIid(ContainmentEndpointLocationKey contEndpointLocationKey,
+ ExternalLocationKey externalLocationKey) {
+ return InstanceIdentifier.builder(EndpointLocations.class)
+ .child(ContainmentEndpointLocation.class, contEndpointLocationKey)
+ .child(RelativeLocations.class)
+ .child(ExternalLocation.class, externalLocationKey)
+ .build();
+ }
+
+ public static InstanceIdentifier<AbsoluteLocation> absoluteLocationIid(AddressEndpointLocationKey addrEndpointLocationKey) {
+ return InstanceIdentifier.builder(EndpointLocations.class)
+ .child(AddressEndpointLocation.class, addrEndpointLocationKey)
+ .child(AbsoluteLocation.class)
+ .build();
+ }
+
+ public static InstanceIdentifier<ProviderAddressEndpointLocation> providerAddressEndpointLocationIid(String provider,
Class<? extends AddressType> addrType, String addr, Class<? extends ContextType> cType,
ContextId containment) {
return InstanceIdentifier.builder(LocationProviders.class)
.child(LocationProvider.class, new LocationProviderKey(new ProviderName(provider)))
- .child(ProviderAddressEndpointLocation.class, new ProviderAddressEndpointLocationKey(addr, addrType, containment, cType));
+ .child(ProviderAddressEndpointLocation.class, new ProviderAddressEndpointLocationKey(addr, addrType, containment, cType))
+ .build();
}
}
policyRuleGroupBuilder.setContractId(ruleGrp.getRelatedContract().getId());
policyRuleGroupBuilder.setSubjectName(ruleGrp.getRelatedSubject());
policyRuleGroupBuilder.setTenantId(ruleGrp.getContractTenant().getId());
+ policyRuleGroupBuilder.setOrder(ruleGrp.getOrder());
policyRuleGroupBuilder
.setResolvedRule(buildResolvedRules(ruleGrp.getRules(), ruleGrp.getContractTenant()));
policyRuleGroups.add(policyRuleGroupBuilder.build());
"The tenant with which this endpoint is associated";
}
container network-containment {
- description
- "The network domain associated with this endpoint's fowarding
- context.";
- uses forwarding:network-domain-key;
+ choice containment {
+ description
+ "The network domain associated with this endpoint's fowarding
+ context.";
+ case network-domain-containment {
+ uses forwarding:network-domain-key;
+ }
+ case forwarding-context-containment {
+ uses forwarding:context-key;
+ }
+ }
}
leaf-list endpoint-group {
type gbp-common:endpoint-group-id;
}
}
- grouping has-regular-location {
- leaf node {
+ grouping internal-location-fields {
+ description "Location inside ODL - node and node-connector
+ are represented directly in ODL.";
+ leaf internal-node {
mandatory true;
type instance-identifier;
}
- leaf node-connector {
+ leaf internal-node-connector {
type instance-identifier;
}
}
- grouping has-external-location {
+ grouping external-location-fields {
+ description "Location outside of ODL - node and node-connector
+ are outside of ODL. external-node-mount-point is path
+ to external system where node and node-connector are located.";
leaf external-node-mount-point {
mandatory true;
type instance-identifier;
}
- leaf external-node-location {
+ leaf external-node {
type string; // TODO switch to external-reference
}
leaf external-node-connector {
}
}
- grouping has-location {
- container real-location {
+ grouping has-absolute-location {
+ container absolute-location {
choice location-type {
- case regular-location-case {
- uses has-regular-location;
+ case internal-location-case {
+ uses internal-location-fields;
}
case external-location-case {
- uses has-external-location;
+ uses external-location-fields;
}
}
}
- container relative-location {
- list location {
- key "node node-connector";
- uses has-regular-location;
+ }
+
+ grouping has-relative-location {
+ container relative-locations {
+ list internal-location {
+ key "internal-node internal-node-connector";
+ uses internal-location-fields;
}
list external-location {
key "external-node-mount-point external-node-connector";
- uses has-external-location;
+ uses external-location-fields;
}
}
}
+ grouping has-location {
+ uses has-absolute-location;
+ uses has-relative-location;
+ }
+
container endpoints {
description
"Repository for operational state data about endpoints needed
list containment-endpoint-location {
key "context-type context-id";
uses forwarding:context-key;
- uses has-location;
+ uses has-relative-location;
}
}
list containment-endpoint-reg {
key "context-type context-id";
uses containment-endpoint-fields;
- uses has-location;
+ uses has-relative-location;
}
}
}
leaf provider {\r
type provider-name;\r
}\r
+ leaf priority {\r
+ type uint32;\r
+ }\r
list provider-address-endpoint-location {\r
key "context-type context-id address-type address";\r
uses base-endpoint:address-endpoint-key;\r
list provider-containment-endpoint-location {\r
key "context-type context-id";\r
uses forwarding:context-key;\r
- uses base-endpoint:has-location;\r
+ uses base-endpoint:has-relative-location;\r
}\r
}\r
}\r
identity context-type {
description "Type of context.";
- base network-domain;
}
typedef address-type-ref {
}
grouping has-endpoint-identification-constraints {
+
+ status deprecated;
+
container endpoint-identification-constraints {
description
"Identify endpoints via other attributes other than conditions.
}
}
- grouping has-peer-containment-endpoints {
- list peer-containment-endpoint {
- key "context-type context-id";
- uses forwarding:context-key;
- }
- }
-
grouping has-peer-external-endpoints {
list peer-external-endpoint {
key "context-type context-id address-type address";
}
}
- container renderers {
- description
- "Leaf containing all renderers' description.";
+ grouping has-rule-group-with-renderer-endpoint-participation {
+ list rule-group-with-renderer-endpoint-participation {
+ description "A specific policy rule group that apply to pair of endpoints.
+ Entire rule-group is located on /renderers/renderer/renderer-policy/configuration/rule-groups/rule-group";
+ key "tenant-id contract-id subject-name renderer-endpoint-participation";
+ uses resolved-policy:has-subject-key;
+ leaf renderer-endpoint-participation {
+ type endpoint-policy-participation;
+ }
+ }
+ }
+ container renderers {
list renderer {
description
"A renderer provides a list of capabilities and status about configured policy.
list renderer-node {
key "node-path";
leaf node-path {
- description "Path to the node where policy needs to be enforced.";
+ description "Path to the node where policy needs to be enforced.
+ This field is matched against internal-node and external-node-mount-point
+ from base-endoint:endpoint-locations.";
type instance-identifier;
}
}
container configuration {
description "Renderer tries to apply given policy on devices.";
- container endpoint-resolved-policies {
- list endpoint-resolved-policy {
- description "Policy between renderer-endpoints and peer-endpoints.";
- key policy-name;
- leaf policy-name {
- description "Key is here only as workaround for bugs around unkeyed list. It can be removed anytime.";
- type policy-name;
- }
+ container renderer-endpoints {
+ list renderer-endpoint {
+ min-elements 1;
+ description "Policy between renderer-endpoint and peer-endpoints (peers).
+ Renderer configures policy for renderer endpoints.";
+ key "context-type context-id address-type address";
+ uses base-endpoint:address-endpoint-key;
- container provided-resolved-policy {
- list provided-rule-group {
- description "A specific policy rule group that apply to pair of endpoints.
- Renderer Endpoint is a provider of the rule group.
- Entire rule-group is located on /renderers/renderer/renderer-policy/configuration/rule-groups/rule-group";
- key "tenant-id contract-id subject-name";
- uses resolved-policy:has-subject-key;
- }
+ list peer-endpoint-with-policy {
+ key "context-type context-id address-type address";
+ uses base-endpoint:address-endpoint-key;
+ uses has-rule-group-with-renderer-endpoint-participation;
}
- container consumed-resolved-policy {
- list consumed-rule-group {
- description "A specific policy rule group that apply to pair of endpoints.
- Renderer Endpoint is a consumer of the rule group.
- Entire rule-group is located on /renderers/renderer/renderer-policy/configuration/rule-groups/rule-group";
- key "tenant-id contract-id subject-name";
- uses resolved-policy:has-subject-key;
- }
+ list peer-external-endpoint-with-policy {
+ key "context-type context-id address-type address";
+ uses base-endpoint:address-endpoint-key;
+ uses has-rule-group-with-renderer-endpoint-participation;
}
- container renderer-endpoints-and-peers {
- description "Every renderer-endpoint has the same set of peer-endpoints.
- A renderer should not configure a policy when renderer-endpoint is peer-endpoint.";
- list renderer-endpoint {
- key "context-type context-id address-type address";
- uses base-endpoint:address-endpoint-key;
- }
- uses has-peer-endpoints;
- uses has-peer-external-endpoints;
- uses has-peer-external-containment-endpoints;
+ list peer-external-containment-endpoint-with-policy {
+ key "context-type context-id";
+ uses forwarding:context-key;
+ uses has-rule-group-with-renderer-endpoint-participation;
}
}
}
container rule-groups {
list rule-group {
+ min-elements 1;
description "A specific policy rule group that apply to pair of endpoints.
The policy rule group represents the subject with resolved rules.";
key "tenant-id contract-id subject-name";
container endpoints {
list address-endpoint-with-location {
+ min-elements 1;
key "context-type context-id address-type address";
uses base-endpoint:address-endpoint-fields;
uses base-endpoint:has-location;
list containment-endpoint-with-location {
key "context-type context-id";
- uses base-endpoint:address-endpoint-fields;
- uses base-endpoint:has-location;
+ uses base-endpoint:containment-endpoint-fields;
+ uses base-endpoint:has-relative-location;
}
}
container forwarding-contexts {
list forwarding-context-by-tenant {
+ min-elements 1;
key tenant-id;
uses forwarding:forwarding-with-tenant-fields;
}
The policy rule group represents the subject with resolved rules.";
key "tenant-id contract-id subject-name";
uses has-subject-key;
+ uses policy:has-order;
uses has-resolved-rules;
}
}
package org.opendaylight.groupbasedpolicy.base_endpoint;
-import com.google.common.util.concurrent.CheckedFuture;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.api.BaseEndpointRendererAugmentation;
-import org.opendaylight.groupbasedpolicy.base_endpoint.BaseEndpointRpcRegistry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.*;
+import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.UnregisterEndpointInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainment;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.ContainmentEndpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.child.endpoints.ChildEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.ParentEndpointChoice;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentContainmentEndpointCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.ParentEndpointCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.parent.child.endpoints.parent.endpoint.choice.parent.endpoint._case.ParentEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.AddressEndpointRegBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointReg;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.register.endpoint.input.ContainmentEndpointRegBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.AddressEndpointUnregBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnreg;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.unregister.endpoint.input.ContainmentEndpointUnregBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.Subnet;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Future;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.*;
-import static org.mockito.internal.verification.VerificationModeFactory.times;
+import javax.annotation.Nonnull;
-public class BaseEndpointRpcRegistryTest {
+public class BaseEndpointRpcRegistryTest extends CustomDataBrokerTest {
private static final String MAC_ADDRESS = "01:23:45:67:89:AB";
+ private static final String IP_ADDRESS = "192.168.100.1/24";
private static final String TENANT = "admin";
private static final String DOMAIN = "test.domain";
private static final String CONTEXT_ID = "testContext";
- private static final String FLOOD_DOMAIN = "testFloodDomain";
+ private static final long timestamp = 1234567890L;
+
+ private enum AddressEndpointRegistration {
+ CHILD, PARENT, BOTH, NONE
+ }
+ private enum AddressEndpointType {
+ L2, L3, BOTH, NONE
+ }
private DataBroker dataProvider;
private BaseEndpointRendererAugmentation baseEndpointRendererAugmentation;
private BaseEndpointRpcRegistry baseEndpointRpcRegistry;
+ private AddressEndpoint basel2Ep;
+ private AddressEndpoint basel3Ep;
+ private ContainmentEndpoint baseContainmentEp;
+ private ParentEndpoint basel3Parent;
+ private ChildEndpoint basel2Child;
+
+ @Nonnull
+ @Override
+ public Collection<Class<?>> getClassesFromModules() {
+ return ImmutableList.of(Endpoints.class, AddressEndpoints.class, ContainmentEndpoints.class,
+ MacAddressType.class, IpPrefixType.class);
+ }
@Before
public void init() {
- dataProvider = mock(DataBroker.class);
+ dataProvider = getDataBroker();
baseEndpointRendererAugmentation = mock(BaseEndpointRendererAugmentation.class);
- WriteTransaction wt = newWriteTransactionMock();
RpcProviderRegistry rpcRegistry = mock(RpcProviderRegistry.class);
baseEndpointRpcRegistry = new BaseEndpointRpcRegistry(dataProvider, rpcRegistry);
+
+ NetworkDomainContainment
+ networkDomainContainment =
+ new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType(
+ Subnet.class).build();
+
+ basel3Parent = new ParentEndpointBuilder().setAddress(IP_ADDRESS)
+ .setAddressType(IpPrefixType.class)
+ .setContextId(new ContextId(CONTEXT_ID))
+ .setContextType(L3Context.class)
+ .build();
+
+ basel2Child = new ChildEndpointBuilder().setAddress(MAC_ADDRESS)
+ .setAddressType(MacAddressType.class)
+ .setContextId(new ContextId(CONTEXT_ID))
+ .setContextType(L2FloodDomain.class)
+ .build();
+
+ basel2Ep = new AddressEndpointBuilder().setTimestamp(timestamp)
+ .setContextId(new ContextId(CONTEXT_ID))
+ .setContextType(L2FloodDomain.class)
+ .setTenant(new TenantId(TENANT))
+ .setAddress(MAC_ADDRESS)
+ .setAddressType(MacAddressType.class)
+ .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build())
+ .setTimestamp(timestamp)
+ .setParentEndpointChoice(
+ new ParentEndpointCaseBuilder().setParentEndpoint(Collections.singletonList(basel3Parent)).build())
+ .build();
+
+ basel3Ep = new AddressEndpointBuilder().setTimestamp(timestamp)
+ .setContextId(new ContextId(CONTEXT_ID))
+ .setContextType(L3Context.class)
+ .setTenant(new TenantId(TENANT))
+ .setAddress(IP_ADDRESS)
+ .setAddressType(IpPrefixType.class)
+ .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build())
+ .setTimestamp(timestamp)
+ .setChildEndpoint(Collections.singletonList(basel2Child))
+ .build();
+
+ baseContainmentEp = new ContainmentEndpointBuilder().setTimestamp(timestamp)
+ .setContextId(new ContextId(CONTEXT_ID))
+ .setContextType(L2FloodDomain.class)
+ .setTenant(new TenantId(TENANT))
+ .setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build())
+ .setChildEndpoint(Collections.singletonList(basel2Child))
+ .build();
}
@Test
@Test
public void testRegisterEndpoint() throws Exception {
- WriteTransaction wt = newWriteTransactionMock();
+ RegisterEndpointInput input =
+ createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.BOTH, true);
- baseEndpointRpcRegistry.registerEndpoint(createRegisterEndpointInputVariablesForTest());
+ baseEndpointRpcRegistry.registerEndpoint(input);
- verify(wt, times(2)).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
- any(DataObject.class), eq(true));
+ ReadOnlyTransaction transaction = dataProvider.newReadOnlyTransaction();
+
+ AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID),
+ L2FloodDomain.class);
+ Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), transaction);
+
+ Assert.assertTrue(addressEndpointL2.isPresent());
+
+ if (addressEndpointL2.isPresent()) {
+ Assert.assertEquals(basel2Ep, addressEndpointL2.get());
+ }
+
+ key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class);
+
+ Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), transaction);
+
+ Assert.assertTrue(addressEndpointL3.isPresent());
+
+ if (addressEndpointL3.isPresent()) {
+ Assert.assertEquals(basel3Ep, addressEndpointL3.get());
+ }
+
+ ContainmentEndpointKey containmentEndpointKey =
+ new ContainmentEndpointKey(new ContextId(CONTEXT_ID), L2FloodDomain.class);
+
+ Optional<ContainmentEndpoint> ContainmentEndpoint = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.containmentEndpointIid(containmentEndpointKey), transaction);
+
+ Assert.assertTrue(ContainmentEndpoint.isPresent());
+
+ if (ContainmentEndpoint.isPresent()) {
+ Assert.assertEquals(baseContainmentEp, ContainmentEndpoint.get());
+ }
}
- private RegisterEndpointInput createRegisterEndpointInputVariablesForTest() throws Exception {
- RegisterEndpointInputBuilder registerEndpointInputBuilder = new RegisterEndpointInputBuilder();
- long timestamp = System.currentTimeMillis();
+ @Test
+ public void testRegisterEndpointWithParentUpdate() throws Exception {
+ setupBasicDataStore();
+ RegisterEndpointInput input =
+ createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.L2, true);
- registerEndpointInputBuilder.setAddressEndpointReg(new ArrayList<>());
- registerEndpointInputBuilder.setContainmentEndpointReg(new ArrayList<>());
+ baseEndpointRpcRegistry.registerEndpoint(input);
- registerEndpointInputBuilder.getAddressEndpointReg().add(
- new AddressEndpointRegBuilder().setTimestamp(timestamp)
- .setContextId(new ContextId(CONTEXT_ID))
- .setContextType(L2FloodDomain.class)
- .setTenant(new TenantId(TENANT))
- .setAddress(MAC_ADDRESS)
- .setAddressType(MacAddressType.class)
- .setAddressType(AddressType.class)
- .setNetworkContainment(new NetworkContainmentBuilder()
- .setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType(Subnet.class).build())
- .setKey(new AddressEndpointRegKey(MAC_ADDRESS,MacAddressType.class, new ContextId(CONTEXT_ID), L2FloodDomain.class))
- .setTimestamp(timestamp).build());
-
- registerEndpointInputBuilder.getContainmentEndpointReg().add(
- new ContainmentEndpointRegBuilder()
- .setTimestamp(timestamp)
- .setContextId(new L2FloodDomainId(FLOOD_DOMAIN))
- .setContextType(L2FloodDomain.class)
- .setTenant(new TenantId(TENANT))
- .setNetworkContainment(new NetworkContainmentBuilder()
- .setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType(Subnet.class).build())
- .setKey(new ContainmentEndpointRegKey(new L2FloodDomainId(FLOOD_DOMAIN),L2FloodDomain.class))
- .build());
+ AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID),
+ L2FloodDomain.class);
+ Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
- return registerEndpointInputBuilder.build();
+ Assert.assertTrue(addressEndpointL2.isPresent());
+
+ if (addressEndpointL2.isPresent()) {
+ ParentEndpointCase parentEndpointCase =
+ (ParentEndpointCase) addressEndpointL2.get().getParentEndpointChoice();
+ List<ParentEndpoint> parentEndpoints = parentEndpointCase.getParentEndpoint();
+ Assert.assertEquals(parentEndpoints.size(), 1);
+ }
+
+ key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class);
+
+ Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL3.isPresent());
+
+ if (addressEndpointL3.isPresent()) {
+ Assert.assertEquals(addressEndpointL3.get().getChildEndpoint().size(), 1);
+ }
+ }
+
+ @Test
+ public void testRegisterEndpointWithParentUpdateFail() throws Exception {
+ RegisterEndpointInput input = createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH,
+ AddressEndpointType.L2, true);
+
+ Future<RpcResult<Void>> rpcResultFuture = baseEndpointRpcRegistry.registerEndpoint(input);
+
+ Assert.assertFalse(rpcResultFuture.get().isSuccessful());
+ Assert.assertNotNull(rpcResultFuture.get().getErrors());
+ Assert.assertEquals(rpcResultFuture.get().getErrors().size(), 1);
+ }
+
+ @Test
+ public void testRegisterEndpointWithChildUpdate() throws Exception {
+ setupBasicDataStore();
+ RegisterEndpointInput input =
+ createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.L3, true);
+
+ baseEndpointRpcRegistry.registerEndpoint(input);
+
+ AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID),
+ L2FloodDomain.class);
+ Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL2.isPresent());
+
+ if (addressEndpointL2.isPresent()) {
+ ParentEndpointCase parentEndpointCase =
+ (ParentEndpointCase) addressEndpointL2.get().getParentEndpointChoice();
+ List<ParentEndpoint> parentEndpoints = parentEndpointCase.getParentEndpoint();
+ Assert.assertEquals(parentEndpoints.size(), 1);
+ }
+
+ key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class);
+
+ Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL3.isPresent());
+
+ if (addressEndpointL3.isPresent()) {
+ Assert.assertEquals(addressEndpointL3.get().getChildEndpoint().size(), 1);
+ }
+ }
+
+ @Test
+ public void testRegisterEndpointWithChildUpdateFail() throws Exception {
+ RegisterEndpointInput input = createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH,
+ AddressEndpointType.L3, true);
+
+ Future<RpcResult<Void>> rpcResultFuture = baseEndpointRpcRegistry.registerEndpoint(input);
+
+ Assert.assertFalse(rpcResultFuture.get().isSuccessful());
+ Assert.assertNotNull(rpcResultFuture.get().getErrors());
+ Assert.assertEquals(rpcResultFuture.get().getErrors().size(), 1);
+ }
+
+ private void setupBasicDataStore() throws Exception {
+ InstanceIdentifier<Endpoints> id = InstanceIdentifier.builder(Endpoints.class).build();
+ dataProvider.newWriteOnlyTransaction().delete(LogicalDatastoreType.OPERATIONAL, id);
+
+ RegisterEndpointInput input =
+ createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.NONE, AddressEndpointType.BOTH, true);
+
+ baseEndpointRpcRegistry.registerEndpoint(input);
+
+ AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID),
+ L2FloodDomain.class);
+ Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL2.isPresent());
+
+ if (addressEndpointL2.isPresent()) {
+ ParentEndpointCase parentEndpointCase =
+ (ParentEndpointCase) addressEndpointL2.get().getParentEndpointChoice();
+ Assert.assertEquals(parentEndpointCase.getParentEndpoint().size(), 0);
+ }
+
+ key = new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class);
+
+ Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL3.isPresent());
+
+ if (addressEndpointL3.isPresent()) {
+ Assert.assertEquals(addressEndpointL3.get().getChildEndpoint().size(), 0);
+ }
}
@Test
- public void testUnregisterEndpoint() throws Exception {
- WriteTransaction wt = newWriteTransactionMock();
+ public void testRegisterEndpointParentFail() throws Exception {
+ Future<RpcResult<Void>> rpcResultFuture =
+ baseEndpointRpcRegistry.registerEndpoint(createRegisterEndpointInputVariablesForTest(
+ AddressEndpointRegistration.PARENT, AddressEndpointType.BOTH, true));
+
+ RpcResult<Void> rpcResult = rpcResultFuture.get();
+
+ Assert.assertFalse(rpcResult.isSuccessful());
+ Assert.assertNull(rpcResult.getResult());
+ Assert.assertEquals(rpcResult.getErrors().size(), 1);
+
+ }
+
+ @Test
+ public void testRegisterEndpointChildFail() throws Exception {
+ Future<RpcResult<Void>> rpcResultFuture =
+ baseEndpointRpcRegistry.registerEndpoint(createRegisterEndpointInputVariablesForTest(
+ AddressEndpointRegistration.CHILD, AddressEndpointType.BOTH, true));
+
+ RpcResult<Void> rpcResult = rpcResultFuture.get();
+
+ Assert.assertFalse(rpcResult.isSuccessful());
+ Assert.assertNull(rpcResult.getResult());
+ Assert.assertEquals(rpcResult.getErrors().size(), 1);
+ }
+
+ @Test
+ public void testUnregisterEndpointWithParent() throws Exception {
+ RegisterEndpointInput input =
+ createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.BOTH, true);
+
+ baseEndpointRpcRegistry.registerEndpoint(input);
- UnregisterEndpointInput unregisterEndpointInput = unregisterEndpointInput();
+ AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID),
+ L2FloodDomain.class);
+ ContainmentEndpointKey cKey = new ContainmentEndpointKey(new ContextId(CONTEXT_ID), L2FloodDomain.class);
- baseEndpointRpcRegistry.unregisterEndpoint(unregisterEndpointInput);
+ Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
- verify(wt, times(2)).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
+ Assert.assertTrue(addressEndpointL2.isPresent());
+
+ if (addressEndpointL2.isPresent()) {
+ Assert.assertEquals(basel2Ep, addressEndpointL2.get());
+ }
+
+ Optional<ContainmentEndpoint> ContainmentEndpoint = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.containmentEndpointIid(cKey), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(ContainmentEndpoint.isPresent());
+
+ if (ContainmentEndpoint.isPresent()) {
+ Assert.assertEquals(baseContainmentEp, ContainmentEndpoint.get());
+ }
+
+ baseEndpointRpcRegistry.unregisterEndpoint(unregisterEndpointInputParent());
+ Optional<AddressEndpoint> endpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertFalse(endpointOptional.isPresent());
+
+ Optional<ContainmentEndpoint> containmentEndpointOptional =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, IidFactory.containmentEndpointIid(cKey),
+ dataProvider.newReadOnlyTransaction());
+
+ Assert.assertFalse(containmentEndpointOptional.isPresent());
}
- private UnregisterEndpointInput unregisterEndpointInput() {
+ @Test
+ public void testUnregisterEndpointWithChild() throws Exception {
+ RegisterEndpointInput input =
+ createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.BOTH, AddressEndpointType.BOTH, true);
+
+ baseEndpointRpcRegistry.registerEndpoint(input);
+
+ AddressEndpointKey key =
+ new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(CONTEXT_ID), L3Context.class);
+
+ Optional<AddressEndpoint> addressEndpointL3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL3.isPresent());
+
+ if (addressEndpointL3.isPresent()) {
+ Assert.assertEquals(basel3Ep, addressEndpointL3.get());
+ }
+
+ baseEndpointRpcRegistry.unregisterEndpoint(unregisterEndpointInputChild());
+ Optional<AddressEndpoint> endpointOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertFalse(endpointOptional.isPresent());
+
+ }
+
+ @Test
+ public void testRegisterContainmentEndpointWithChildFail() throws Exception {
+ Future<RpcResult<Void>> rpcResultFuture =
+ baseEndpointRpcRegistry.registerEndpoint(createRegisterEndpointInputVariablesForTest(
+ AddressEndpointRegistration.NONE, AddressEndpointType.NONE, true));
+
+ RpcResult<Void> rpcResult = rpcResultFuture.get();
+
+ Assert.assertFalse(rpcResult.isSuccessful());
+ Assert.assertNull(rpcResult.getResult());
+ Assert.assertEquals(rpcResult.getErrors().size(), 1);
+ }
+
+ @Test
+ public void testUnregisterContainmentEndpointWithChild() throws Exception {
+ InstanceIdentifier<Endpoints> id = InstanceIdentifier.builder(Endpoints.class).build();
+ dataProvider.newWriteOnlyTransaction().delete(LogicalDatastoreType.OPERATIONAL, id);
+
+ RegisterEndpointInput input =
+ createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration.NONE, AddressEndpointType.L2, false);
+
+ baseEndpointRpcRegistry.registerEndpoint(input);
+
+ AddressEndpointKey key = new AddressEndpointKey(MAC_ADDRESS, MacAddressType.class, new ContextId(CONTEXT_ID),
+ L2FloodDomain.class);
+
+ Optional<AddressEndpoint> addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL2.isPresent());
+ if (addressEndpointL2.isPresent()){
+ ParentEndpointChoice parentEndpointChoice = addressEndpointL2.get().getParentEndpointChoice();
+ if(parentEndpointChoice instanceof ParentContainmentEndpointCase){
+ ParentContainmentEndpointCase
+ parentEndpointCase = (ParentContainmentEndpointCase) parentEndpointChoice;
+ Assert.assertNull(parentEndpointCase.getParentContainmentEndpoint());
+ }
+ }
+
+ ContainmentEndpointReg containmentEndpointReg = new ContainmentEndpointRegBuilder().setTimestamp(baseContainmentEp.getTimestamp())
+ .setContextId(baseContainmentEp.getContextId())
+ .setContextType(baseContainmentEp.getContextType())
+ .setTenant(baseContainmentEp.getTenant())
+ .setNetworkContainment(baseContainmentEp.getNetworkContainment())
+ .setChildEndpoint(Collections.singletonList(basel2Child))
+ .build();
+
+ baseEndpointRpcRegistry.registerEndpoint(new RegisterEndpointInputBuilder().setContainmentEndpointReg(Collections.singletonList(containmentEndpointReg)).build());
+
+ addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL2.isPresent());
+ if (addressEndpointL2.isPresent()) {
+ ParentEndpointChoice parentEndpointChoice = addressEndpointL2.get().getParentEndpointChoice();
+ if(parentEndpointChoice instanceof ParentContainmentEndpointCase){
+ ParentContainmentEndpointCase
+ parentEndpointCase = (ParentContainmentEndpointCase) parentEndpointChoice;
+ Assert.assertNotNull(parentEndpointCase.getParentContainmentEndpoint());
+ Assert.assertEquals(parentEndpointCase.getParentContainmentEndpoint().size(),1);
+ }
+ }
+
+ ContainmentEndpointUnreg containmentEndpointUnreg = new ContainmentEndpointUnregBuilder()
+ .setContextId(baseContainmentEp.getContextId())
+ .setContextType(baseContainmentEp.getContextType())
+ .build();
+
+ baseEndpointRpcRegistry.unregisterEndpoint(new UnregisterEndpointInputBuilder().setContainmentEndpointUnreg(Collections.singletonList(containmentEndpointUnreg)).build());
+
+ addressEndpointL2 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.addressEndpointIid(key), dataProvider.newReadOnlyTransaction());
+
+ Assert.assertTrue(addressEndpointL2.isPresent());
+ if (addressEndpointL2.isPresent()) {
+ ParentEndpointChoice parentEndpointChoice = addressEndpointL2.get().getParentEndpointChoice();
+ if(parentEndpointChoice instanceof ParentContainmentEndpointCase){
+ ParentContainmentEndpointCase
+ parentEndpointCase = (ParentContainmentEndpointCase) parentEndpointChoice;
+ Assert.assertNotNull(parentEndpointCase.getParentContainmentEndpoint());
+ Assert.assertEquals(parentEndpointCase.getParentContainmentEndpoint().size(),0);
+ }
+ }
+
+ }
+
+ private UnregisterEndpointInput unregisterEndpointInputParent() {
UnregisterEndpointInputBuilder builder = new UnregisterEndpointInputBuilder();
builder.setAddressEndpointUnreg(new ArrayList<>());
return builder.build();
}
- private WriteTransaction newWriteTransactionMock() {
- WriteTransaction wt = mock(WriteTransaction.class);
- CheckedFuture<Void, TransactionCommitFailedException> f = mock(CheckedFuture.class);
+ private UnregisterEndpointInput unregisterEndpointInputChild() {
+ UnregisterEndpointInputBuilder builder = new UnregisterEndpointInputBuilder();
+
+ builder.setAddressEndpointUnreg(new ArrayList<>());
+ builder.setContainmentEndpointUnreg(new ArrayList<>());
- when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);
- when(wt.submit()).thenReturn(f);
- return wt;
+ builder.getAddressEndpointUnreg().add(new AddressEndpointUnregBuilder().setContextId(new ContextId(CONTEXT_ID))
+ .setContextType(L3Context.class)
+ .setAddress(IP_ADDRESS)
+ .setAddressType(IpPrefixType.class)
+ .build());
+
+ return builder.build();
}
+ private RegisterEndpointInput createRegisterEndpointInputVariablesForTest(AddressEndpointRegistration registration,
+ AddressEndpointType type, boolean containmentEpPresent) throws Exception {
+ RegisterEndpointInputBuilder registerEndpointInputBuilder = new RegisterEndpointInputBuilder();
+ long timestamp = System.currentTimeMillis();
+
+ List<ParentEndpoint> parentEndpoints = new ArrayList<>();
+ if (registration == AddressEndpointRegistration.BOTH || registration == AddressEndpointRegistration.PARENT) {
+ parentEndpoints.add(basel3Parent);
+ }
+
+ List<ChildEndpoint> childEndpoints = new ArrayList<>();
+ if (registration == AddressEndpointRegistration.BOTH || registration == AddressEndpointRegistration.CHILD) {
+ childEndpoints.add(basel2Child);
+ }
+
+ registerEndpointInputBuilder.setAddressEndpointReg(new ArrayList<>());
+ registerEndpointInputBuilder.setContainmentEndpointReg(new ArrayList<>());
+
+ if (type == AddressEndpointType.BOTH || type == AddressEndpointType.L2) {
+ registerEndpointInputBuilder.getAddressEndpointReg()
+ .add(new AddressEndpointRegBuilder().setTimestamp(timestamp)
+ .setContextId(basel2Ep.getContextId())
+ .setContextType(basel2Ep.getContextType())
+ .setTenant(basel2Ep.getTenant())
+ .setAddress(basel2Ep.getAddress())
+ .setAddressType(basel2Ep.getAddressType())
+ .setNetworkContainment(basel2Ep.getNetworkContainment())
+ .setTimestamp(basel2Ep.getTimestamp())
+ .setParentEndpointChoice(new ParentEndpointCaseBuilder().setParentEndpoint(parentEndpoints).build())
+ .build());
+ }
+
+ if (type == AddressEndpointType.BOTH || type == AddressEndpointType.L3) {
+ registerEndpointInputBuilder.getAddressEndpointReg()
+ .add(new AddressEndpointRegBuilder().setContextId(basel3Ep.getContextId())
+ .setContextType(basel3Ep.getContextType())
+ .setTenant(basel3Ep.getTenant())
+ .setAddress(basel3Ep.getAddress())
+ .setAddressType(basel3Ep.getAddressType())
+ .setNetworkContainment(basel3Ep.getNetworkContainment())
+ .setTimestamp(basel3Ep.getTimestamp())
+ .setChildEndpoint(childEndpoints)
+ .build());
+ }
+
+ if(containmentEpPresent) {
+ registerEndpointInputBuilder.getContainmentEndpointReg()
+ .add(new ContainmentEndpointRegBuilder().setTimestamp(baseContainmentEp.getTimestamp())
+ .setContextId(baseContainmentEp.getContextId())
+ .setContextType(baseContainmentEp.getContextType())
+ .setTenant(baseContainmentEp.getTenant())
+ .setNetworkContainment(baseContainmentEp.getNetworkContainment())
+ .setChildEndpoint(Collections.singletonList(basel2Child))
+ .build());
+ }
+
+ return registerEndpointInputBuilder.build();
+ }
}
/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
package org.opendaylight.groupbasedpolicy.endpoint;
-import static org.mockito.Mockito.mock;
-
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class EpKeyTest {
private EpKey epKey;
-
private L2ContextId l2Context;
private MacAddress macAddress;
@Before
- public void initialisation() {
- l2Context = mock(L2ContextId.class);
- macAddress = mock(MacAddress.class);
-
+ public void init() {
+ l2Context = new L2ContextId("l2ctxId");
+ macAddress = new MacAddress("00:00:00:00:00:01");
epKey = new EpKey(l2Context, macAddress);
}
@Test
- public void constructorTest() {
+ public void testConstructor() {
Assert.assertEquals(l2Context, epKey.getL2Context());
Assert.assertEquals(macAddress, epKey.getMacAddress());
}
@Test
- public void equalsTest() {
+ public void testEquals() {
Assert.assertTrue(epKey.equals(epKey));
Assert.assertFalse(epKey.equals(null));
Assert.assertFalse(epKey.equals(new Object()));
EpKey other;
- MacAddress macAddressOther = mock(MacAddress.class);
- L2ContextId l2ContextIdOther = mock(L2ContextId.class);
+ MacAddress macAddressOther = new MacAddress("00:00:00:00:00:02");;
+ L2ContextId l2ContextIdOther = new L2ContextId("l2ctxId-other");
other = new EpKey(l2Context, macAddressOther);
Assert.assertFalse(epKey.equals(other));
other = new EpKey(l2ContextIdOther, macAddress);
}
@Test
- public void toStringTest() {
+ public void testToString() {
Assert.assertNotNull(epKey.toString());
}
}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.location.resolver;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.RelativeLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.RelativeLocationsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.ProviderName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProviderBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProviderKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderContainmentEndpointLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+
+public class LocationResolverTest extends CustomDataBrokerTest {
+
+ private final String PROVIDER_NAME = "location-provider";
+ private final String ADDRESS = "192.168.50.20/24";
+ private final String NODE_1 = "node1";
+ private final String NODE_2 = "node2";
+ private final String NODE_CONNNECTOR = "connector";
+ private final ContextId contextId = new ContextId("context");
+
+ private InstanceIdentifier<Node> nodeIid1 =
+ InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(new NodeId(NODE_1))).build();
+ private InstanceIdentifier<Node> nodeIid2 =
+ InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(new NodeId(NODE_2))).build();
+ private InstanceIdentifier<NodeConnector> connectorIid = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, new NodeKey(new NodeId(NODE_1)))
+ .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId(NODE_CONNNECTOR)))
+ .build();
+ private DataBroker dataBroker;
+ private LocationResolver resolver;
+
+ @Before
+ public void init() {
+ dataBroker = getDataBroker();
+ resolver = new LocationResolver(dataBroker);
+ }
+
+ @Override
+ public Collection<Class<?>> getClassesFromModules() {
+ return ImmutableList.<Class<?>>of(LocationProvider.class, Nodes.class, L3Context.class,
+ EndpointLocations.class);
+ }
+
+ @Test
+ public void test_LocationProviderWrite() throws Exception {
+ AbsoluteLocation absoluteLocation =
+ new AbsoluteLocationBuilder().setLocationType(new InternalLocationCaseBuilder()
+ .setInternalNode(nodeIid1).setInternalNodeConnector(connectorIid).build()).build();
+ RelativeLocations relativeLocations = new RelativeLocationsBuilder()
+ .setInternalLocation(Collections.singletonList(new InternalLocationBuilder().setInternalNode(nodeIid1)
+ .setInternalNodeConnector(connectorIid)
+ .build()))
+ .build();
+ LocationProvider provider = new LocationProviderBuilder().setProvider(new ProviderName(PROVIDER_NAME))
+ .setProviderAddressEndpointLocation(
+ Collections.singletonList(new ProviderAddressEndpointLocationBuilder()
+ .setKey(new ProviderAddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId,
+ L3Context.class))
+ .setAbsoluteLocation(absoluteLocation)
+ .setRelativeLocations(relativeLocations)
+ .build()))
+ .setProviderContainmentEndpointLocation(
+ Collections.singletonList(new ProviderContainmentEndpointLocationBuilder().setContextId(contextId)
+ .setContextType(L3Context.class)
+ .setRelativeLocations(relativeLocations)
+ .build()))
+ .build();
+ InstanceIdentifier<LocationProvider> iid = InstanceIdentifier.builder(LocationProviders.class)
+ .child(LocationProvider.class, provider.getKey())
+ .build();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.OPERATIONAL, iid, provider);
+ wtx.submit().get();
+
+ ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<EndpointLocations> readIid = InstanceIdentifier.builder(EndpointLocations.class).build();
+ Optional<EndpointLocations> read = rtx.read(LogicalDatastoreType.OPERATIONAL, readIid).get();
+ assertTrue(read.isPresent());
+ EndpointLocations readLocations = read.get();
+ assertNotNull(readLocations.getAddressEndpointLocation());
+ assertEquals(1, readLocations.getAddressEndpointLocation().size());
+ assertEquals(new AddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class),
+ readLocations.getAddressEndpointLocation().get(0).getKey());
+ assertEquals(absoluteLocation, readLocations.getAddressEndpointLocation().get(0).getAbsoluteLocation());
+ assertNotNull(readLocations.getContainmentEndpointLocation());
+ assertEquals(1, readLocations.getContainmentEndpointLocation().size());
+ assertEquals(new ContainmentEndpointLocationKey(contextId, L3Context.class),
+ readLocations.getContainmentEndpointLocation().get(0).getKey());
+ assertEquals(relativeLocations, readLocations.getContainmentEndpointLocation().get(0).getRelativeLocations());
+ }
+
+ @Test
+ public void test_LocationProviderOverWrite() throws Exception {
+ test_LocationProviderWrite();
+ AbsoluteLocation absoluteLocation =
+ new AbsoluteLocationBuilder().setLocationType(new InternalLocationCaseBuilder()
+ .setInternalNode(nodeIid2).setInternalNodeConnector(connectorIid).build()).build();
+ RelativeLocations relativeLocations = new RelativeLocationsBuilder()
+ .setInternalLocation(Collections.singletonList(new InternalLocationBuilder().setInternalNode(nodeIid2)
+ .setInternalNodeConnector(connectorIid)
+ .build()))
+ .build();
+ LocationProvider provider = new LocationProviderBuilder().setProvider(new ProviderName(PROVIDER_NAME))
+ .setProviderAddressEndpointLocation(
+ Collections.singletonList(new ProviderAddressEndpointLocationBuilder()
+ .setKey(new ProviderAddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId,
+ L3Context.class))
+ .setAbsoluteLocation(absoluteLocation)
+ .setRelativeLocations(relativeLocations)
+ .build()))
+ .setProviderContainmentEndpointLocation(
+ Collections.singletonList(new ProviderContainmentEndpointLocationBuilder().setContextId(contextId)
+ .setContextType(L3Context.class)
+ .setRelativeLocations(relativeLocations)
+ .build()))
+ .build();
+ InstanceIdentifier<LocationProvider> iid = InstanceIdentifier.builder(LocationProviders.class)
+ .child(LocationProvider.class, provider.getKey())
+ .build();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.OPERATIONAL, iid, provider);
+ wtx.submit().get();
+
+ ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<EndpointLocations> readIid = InstanceIdentifier.builder(EndpointLocations.class).build();
+ Optional<EndpointLocations> read = rtx.read(LogicalDatastoreType.OPERATIONAL, readIid).get();
+ assertTrue(read.isPresent());
+ EndpointLocations readLocations = read.get();
+ assertNotNull(readLocations.getAddressEndpointLocation());
+ assertEquals(1, readLocations.getAddressEndpointLocation().size());
+ assertEquals(new AddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class),
+ readLocations.getAddressEndpointLocation().get(0).getKey());
+ assertEquals(absoluteLocation, readLocations.getAddressEndpointLocation().get(0).getAbsoluteLocation());
+ assertNotNull(readLocations.getContainmentEndpointLocation());
+ assertEquals(1, readLocations.getContainmentEndpointLocation().size());
+ assertEquals(new ContainmentEndpointLocationKey(contextId, L3Context.class),
+ readLocations.getContainmentEndpointLocation().get(0).getKey());
+ assertEquals(relativeLocations, readLocations.getContainmentEndpointLocation().get(0).getRelativeLocations());
+ }
+
+ @Test
+ public void test_LocationProviderDelete() throws Exception {
+ test_LocationProviderWrite();
+ InstanceIdentifier<LocationProvider> iid = InstanceIdentifier.builder(LocationProviders.class)
+ .child(LocationProvider.class, new LocationProviderKey(new ProviderName(PROVIDER_NAME)))
+ .build();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ wtx.submit().get();
+
+ ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<EndpointLocations> readIid = InstanceIdentifier.builder(EndpointLocations.class).build();
+ Optional<EndpointLocations> read = rtx.read(LogicalDatastoreType.OPERATIONAL, readIid).get();
+ assertTrue(read.isPresent());
+ EndpointLocations readLocations = read.get();
+ assertEquals(1, readLocations.getAddressEndpointLocation().size());
+ assertNull(readLocations.getAddressEndpointLocation().get(0).getAbsoluteLocation());
+ assertTrue(readLocations.getAddressEndpointLocation()
+ .get(0)
+ .getRelativeLocations()
+ .getInternalLocation()
+ .isEmpty());
+ assertNull(readLocations.getAddressEndpointLocation().get(0).getRelativeLocations().getExternalLocation());
+ assertEquals(1, readLocations.getContainmentEndpointLocation().size());
+ assertTrue(readLocations.getAddressEndpointLocation()
+ .get(0)
+ .getRelativeLocations()
+ .getInternalLocation()
+ .isEmpty());
+ assertNull(readLocations.getAddressEndpointLocation().get(0).getRelativeLocations().getExternalLocation());
+ }
+
+ @Test
+ public void test_LocationProviderModify() throws Exception {
+ test_LocationProviderWrite();
+ AbsoluteLocation absoluteLocation =
+ new AbsoluteLocationBuilder().setLocationType(new InternalLocationCaseBuilder()
+ .setInternalNode(nodeIid2).setInternalNodeConnector(connectorIid).build()).build();
+ InstanceIdentifier<AbsoluteLocation> iid = InstanceIdentifier.builder(LocationProviders.class)
+ .child(LocationProvider.class, new LocationProviderKey(new ProviderName(PROVIDER_NAME)))
+ .child(ProviderAddressEndpointLocation.class,
+ new ProviderAddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class))
+ .child(AbsoluteLocation.class)
+ .build();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.OPERATIONAL, iid, absoluteLocation);
+ wtx.submit().get();
+
+ ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<EndpointLocations> readIid = InstanceIdentifier.builder(EndpointLocations.class).build();
+ Optional<EndpointLocations> read = rtx.read(LogicalDatastoreType.OPERATIONAL, readIid).get();
+ assertTrue(read.isPresent());
+ EndpointLocations readLocations = read.get();
+ assertNotNull(readLocations.getAddressEndpointLocation());
+ assertEquals(1, readLocations.getAddressEndpointLocation().size());
+ assertEquals(new AddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class),
+ readLocations.getAddressEndpointLocation().get(0).getKey());
+ assertEquals(absoluteLocation, readLocations.getAddressEndpointLocation().get(0).getAbsoluteLocation());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.Arrays;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocationsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.ContainmentEndpointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ForwardingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenantBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.with.tenant.fields.ForwardingContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.Tenants;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RenderersBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.Configuration;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.ForwardingContexts;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPoliciesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRule;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy.ExternalImplicitGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.CheckedFuture;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RendererManagerDataBrokerTest {
+
+ private static final RendererName RENDERER_NAME_R1 = new RendererName("R1");
+ private static final EndpointGroupId EPG_BLUE = new EndpointGroupId("blue_epg");
+ private static final EndpointGroupId EPG_PURPLE = new EndpointGroupId("purple_epg");
+ private static final ContractId CONTRACT_1 = new ContractId("contract_1");
+ private static final SubjectName SUBJECT_1 = new SubjectName("subject_1");
+ private static final RuleName RULE_1 = new RuleName("rule_1");
+ private static final String ADR_1 = "adr_1";
+ private static final String ADR_2 = "adr_2";
+ private static final InstanceIdentifier<?> NODE_PATH_1 = InstanceIdentifier.create(Tenants.class);
+ private static final InternalLocationCase INT_LOC_CASE_NODE_PATH_1 =
+ new InternalLocationCaseBuilder().setInternalNode(NODE_PATH_1).build();
+ private static final InternalLocation INT_LOC_NODE_PATH_1 =
+ new InternalLocationBuilder().setInternalNode(NODE_PATH_1).build();
+ private static final ExternalLocationCase EXT_LOC_CASE_NODE_PATH_1 =
+ new ExternalLocationCaseBuilder().setExternalNodeMountPoint(NODE_PATH_1).build();
+
+ @Mock
+ private DataBroker dataProvider;
+ @Mock
+ private WriteTransaction wTx;
+ @Mock
+ private CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
+
+ private RendererManager rendererManager;
+
+ @Before
+ public void init() {
+ Mockito.when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
+ Mockito.when(wTx.submit()).thenReturn(submitFuture);
+ rendererManager = new RendererManager(dataProvider);
+ RendererManager.resetVersion();
+ }
+
+ /**
+ * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE--EP2
+ */
+ @Test
+ public void testProcessState_dispatchOnePolicy_rendererFeedbackPositive() throws Exception {
+ ArgumentCaptor<Renderers> acRenderers = ArgumentCaptor.forClass(Renderers.class);
+ ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
+ PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
+ ResolvedPolicy resolvedPolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1).build();
+ ResolvedPolicies resolvedPolicies =
+ new ResolvedPoliciesBuilder().setResolvedPolicy(ImmutableList.of(resolvedPolicy)).build();
+ rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
+
+ AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
+ AddressEndpoint ep2 = TestDataFactory.defaultAdrEp(ADR_2, EPG_PURPLE).build();
+ rendererManager.endpointsUpdated(new EndpointsBuilder()
+ .setAddressEndpoints(new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1, ep2)).build())
+ .build());
+
+ AddressEndpointLocation ep1Loc =
+ TestDataFactory.defaultAdrEpLoc(ep1.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
+ AddressEndpointLocation ep2Loc =
+ TestDataFactory.defaultAdrEpLoc(ep2.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
+ EndpointLocations endpointLocations =
+ new EndpointLocationsBuilder().setAddressEndpointLocation(ImmutableList.of(ep1Loc, ep2Loc)).build();
+ rendererManager.endpointLocationsUpdated(endpointLocations);
+
+ rendererManager
+ .forwardingUpdated(new ForwardingBuilder()
+ .setForwardingByTenant(
+ Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
+ .setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
+ .setContextType(TestDataFactory.DummyContextType.class)
+ .setContextId(TestDataFactory.CTX_1)
+ .build()))
+ .build()))
+ .build());
+
+ rendererManager.renderersUpdated(new RenderersBuilder()
+ .setRenderer(Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
+ .setRendererNodes(new RendererNodesBuilder()
+ .setRendererNode(Arrays.asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build())).build())
+ .build()))
+ .build());
+
+ // assert dispatch one policy
+ Assert.assertEquals(1, rendererManager.getProcessingRenderers().size());
+ Mockito.verify(wTx).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
+ Mockito.eq(InstanceIdentifier.create(Renderers.class)),
+ acRenderers.capture());
+
+ Renderers renderers = acRenderers.getValue();
+ Assert.assertNotNull(renderers);
+ Assert.assertNotNull(renderers.getRenderer());
+ Assert.assertEquals(1, renderers.getRenderer().size());
+ Renderer renderer = renderers.getRenderer().get(0);
+ Assert.assertEquals(RENDERER_NAME_R1, renderer.getName());
+ RendererPolicy rendererPolicy = renderer.getRendererPolicy();
+ Assert.assertNotNull(rendererPolicy);
+ Assert.assertEquals(1, rendererPolicy.getVersion().longValue());
+
+ Configuration configuration = rendererPolicy.getConfiguration();
+ Assert.assertNotNull(configuration);
+ RendererEndpoints rendererEndpoints = configuration.getRendererEndpoints();
+ Assert.assertNotNull(rendererEndpoints);
+ Assert.assertEquals(2, rendererEndpoints.getRendererEndpoint().size());
+
+ ForwardingContexts forwardingContexts = configuration.getForwardingContexts();
+ Assert.assertNotNull(forwardingContexts);
+ Assert.assertEquals(1, forwardingContexts.getForwardingContextByTenant().size());
+
+ Endpoints endpoints = configuration.getEndpoints();
+ Assert.assertNotNull(endpoints);
+ Assert.assertEquals(2, endpoints.getAddressEndpointWithLocation().size());
+
+ RuleGroups ruleGroups = configuration.getRuleGroups();
+ Assert.assertNotNull(ruleGroups);
+ Assert.assertEquals(1, ruleGroups.getRuleGroup().size());
+
+ rendererManager
+ .renderersUpdated(
+ new RenderersBuilder()
+ .setRenderer(
+ Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
+ .setRendererNodes(new RendererNodesBuilder()
+ .setRendererNode(Arrays
+ .asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build()))
+ .build())
+ .setRendererPolicy(new RendererPolicyBuilder().setVersion(1L).build())
+ .build()))
+ .build());
+ Assert.assertEquals(0, rendererManager.getProcessingRenderers().size());
+ }
+
+ /**
+ * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE(EIG)--EP2(containment)
+ */
+ @Test
+ public void testProcessState_dispatchOneExternalPolicyWithContainmentEp_noRendererFeedback() throws Exception {
+ ArgumentCaptor<Renderers> acRenderers = ArgumentCaptor.forClass(Renderers.class);
+ ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
+ PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
+ ResolvedPolicy resolvedPolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1)
+ .setExternalImplicitGroup(ExternalImplicitGroup.ProviderEpg)
+ .build();
+ ResolvedPolicies resolvedPolicies =
+ new ResolvedPoliciesBuilder().setResolvedPolicy(ImmutableList.of(resolvedPolicy)).build();
+ rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
+
+ AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
+ ContainmentEndpoint ep2 = TestDataFactory.defaultContEp(EPG_PURPLE).build();
+ rendererManager
+ .endpointsUpdated(new EndpointsBuilder()
+ .setAddressEndpoints(new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1)).build())
+ .setContainmentEndpoints(
+ new ContainmentEndpointsBuilder().setContainmentEndpoint(ImmutableList.of(ep2)).build())
+ .build());
+
+ AddressEndpointLocation ep1Loc =
+ TestDataFactory.defaultAdrEpLoc(ep1.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
+ ContainmentEndpointLocation ep2Loc =
+ TestDataFactory.defaultContEpLoc(ep2.getKey(), INT_LOC_NODE_PATH_1).build();
+ EndpointLocations endpointLocations =
+ new EndpointLocationsBuilder().setAddressEndpointLocation(ImmutableList.of(ep1Loc))
+ .setContainmentEndpointLocation(ImmutableList.of(ep2Loc))
+ .build();
+ rendererManager.endpointLocationsUpdated(endpointLocations);
+
+ rendererManager
+ .forwardingUpdated(new ForwardingBuilder()
+ .setForwardingByTenant(
+ Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
+ .setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
+ .setContextType(TestDataFactory.DummyContextType.class)
+ .setContextId(TestDataFactory.CTX_1)
+ .build()))
+ .build()))
+ .build());
+
+ rendererManager.renderersUpdated(new RenderersBuilder()
+ .setRenderer(Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
+ .setRendererNodes(new RendererNodesBuilder()
+ .setRendererNode(Arrays.asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build())).build())
+ .build()))
+ .build());
+
+ // assert dispatch one policy
+ Assert.assertEquals(1, rendererManager.getProcessingRenderers().size());
+ Mockito.verify(wTx).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
+ Mockito.eq(InstanceIdentifier.create(Renderers.class)),
+ acRenderers.capture());
+
+ Renderers renderers = acRenderers.getValue();
+ Assert.assertNotNull(renderers);
+ Assert.assertNotNull(renderers.getRenderer());
+ Assert.assertEquals(1, renderers.getRenderer().size());
+ Renderer renderer = renderers.getRenderer().get(0);
+ Assert.assertEquals(RENDERER_NAME_R1, renderer.getName());
+ RendererPolicy rendererPolicy = renderer.getRendererPolicy();
+ Assert.assertNotNull(rendererPolicy);
+ Assert.assertEquals(1, rendererPolicy.getVersion().longValue());
+
+ Configuration configuration = rendererPolicy.getConfiguration();
+ Assert.assertNotNull(configuration);
+ RendererEndpoints rendererEndpoints = configuration.getRendererEndpoints();
+ Assert.assertNotNull(rendererEndpoints);
+ Assert.assertEquals(1, rendererEndpoints.getRendererEndpoint().size());
+
+ ForwardingContexts forwardingContexts = configuration.getForwardingContexts();
+ Assert.assertNotNull(forwardingContexts);
+ Assert.assertEquals(1, forwardingContexts.getForwardingContextByTenant().size());
+
+ Endpoints endpoints = configuration.getEndpoints();
+ Assert.assertNotNull(endpoints);
+ Assert.assertEquals(1, endpoints.getAddressEndpointWithLocation().size());
+ Assert.assertEquals(1, endpoints.getContainmentEndpointWithLocation().size());
+
+ RuleGroups ruleGroups = configuration.getRuleGroups();
+ Assert.assertNotNull(ruleGroups);
+ Assert.assertEquals(1, ruleGroups.getRuleGroup().size());
+ }
+
+ /**
+ * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE(EIG)--EP2()
+ */
+ @Test
+ public void testProcessState_dispatchOneExternalPolicyWithEp_noRendererFeedback() {
+ ArgumentCaptor<Renderers> acRenderers = ArgumentCaptor.forClass(Renderers.class);
+ ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
+ PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
+ ResolvedPolicy resolvedPolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1)
+ .setExternalImplicitGroup(ExternalImplicitGroup.ProviderEpg)
+ .build();
+ ResolvedPolicies resolvedPolicies =
+ new ResolvedPoliciesBuilder().setResolvedPolicy(ImmutableList.of(resolvedPolicy)).build();
+ rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
+
+ AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
+ AddressEndpoint ep2 = TestDataFactory.defaultAdrEp(ADR_2, EPG_PURPLE).build();
+ rendererManager.endpointsUpdated(new EndpointsBuilder()
+ .setAddressEndpoints(new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1, ep2)).build())
+ .build());
+
+ AddressEndpointLocation ep1Loc =
+ TestDataFactory.defaultAdrEpLoc(ep1.getKey(), INT_LOC_CASE_NODE_PATH_1).build();
+ AddressEndpointLocation ep2Loc =
+ TestDataFactory.defaultAdrEpLoc(ep2.getKey(), EXT_LOC_CASE_NODE_PATH_1).build();
+ EndpointLocations endpointLocations =
+ new EndpointLocationsBuilder().setAddressEndpointLocation(ImmutableList.of(ep1Loc, ep2Loc)).build();
+ rendererManager.endpointLocationsUpdated(endpointLocations);
+
+ rendererManager
+ .forwardingUpdated(new ForwardingBuilder()
+ .setForwardingByTenant(
+ Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
+ .setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
+ .setContextType(TestDataFactory.DummyContextType.class)
+ .setContextId(TestDataFactory.CTX_1)
+ .build()))
+ .build()))
+ .build());
+
+ rendererManager.renderersUpdated(new RenderersBuilder()
+ .setRenderer(Arrays.asList(new RendererBuilder().setName(RENDERER_NAME_R1)
+ .setRendererNodes(new RendererNodesBuilder()
+ .setRendererNode(Arrays.asList(new RendererNodeBuilder().setNodePath(NODE_PATH_1).build())).build())
+ .build()))
+ .build());
+
+ // assert dispatch one policy
+ Assert.assertEquals(1, rendererManager.getProcessingRenderers().size());
+ Mockito.verify(wTx).put(Mockito.eq(LogicalDatastoreType.CONFIGURATION),
+ Mockito.eq(InstanceIdentifier.create(Renderers.class)),
+ acRenderers.capture());
+
+ Renderers renderers = acRenderers.getValue();
+ Assert.assertNotNull(renderers);
+ Assert.assertNotNull(renderers.getRenderer());
+ Assert.assertEquals(1, renderers.getRenderer().size());
+ Renderer renderer = renderers.getRenderer().get(0);
+ Assert.assertEquals(RENDERER_NAME_R1, renderer.getName());
+ RendererPolicy rendererPolicy = renderer.getRendererPolicy();
+ Assert.assertNotNull(rendererPolicy);
+ Assert.assertEquals(1, rendererPolicy.getVersion().longValue());
+
+ Configuration configuration = rendererPolicy.getConfiguration();
+ Assert.assertNotNull(configuration);
+ RendererEndpoints rendererEndpoints = configuration.getRendererEndpoints();
+ Assert.assertNotNull(rendererEndpoints);
+ Assert.assertEquals(1, rendererEndpoints.getRendererEndpoint().size());
+
+ ForwardingContexts forwardingContexts = configuration.getForwardingContexts();
+ Assert.assertNotNull(forwardingContexts);
+ Assert.assertEquals(1, forwardingContexts.getForwardingContextByTenant().size());
+
+ Endpoints endpoints = configuration.getEndpoints();
+ Assert.assertNotNull(endpoints);
+ Assert.assertEquals(2, endpoints.getAddressEndpointWithLocation().size());
+
+ RuleGroups ruleGroups = configuration.getRuleGroups();
+ Assert.assertNotNull(ruleGroups);
+ Assert.assertEquals(1, ruleGroups.getRuleGroup().size());
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Set;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocationsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpointsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.Tenants;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.endpoints.PeerEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPoliciesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRule;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableTable;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RendererManagerTest {
+
+ private static final EndpointGroupId EPG_BLUE = new EndpointGroupId("blue_epg");
+ private static final EndpointGroupId EPG_PURPLE = new EndpointGroupId("purple_epg");
+ private static final EndpointGroupId EPG_RED = new EndpointGroupId("red_epg");
+ private static final EndpointGroupId EPG_GREY = new EndpointGroupId("grey_epg");
+ private static final ContractId CONTRACT_1 = new ContractId("contract_1");
+ private static final SubjectName SUBJECT_1 = new SubjectName("subject_1");
+ private static final RuleName RULE_1 = new RuleName("rule_1");
+ private static final ContractId CONTRACT_2 = new ContractId("contract_2");
+ private static final SubjectName SUBJECT_2 = new SubjectName("subject_2");
+ private static final String ADR_1 = "adr_1";
+ private static final String ADR_2 = "adr_2";
+ private static final String ADR_3 = "adr_3";
+ private static final String ADR_4 = "adr_4";
+ private static final InstanceIdentifier<?> NODE_PATH_1 = InstanceIdentifier.create(Tenants.class);
+ private static final InternalLocationCase REG_LOC_NODE_PATH_1 =
+ new InternalLocationCaseBuilder().setInternalNode(NODE_PATH_1).build();
+
+ @Mock
+ private DataBroker dataProvider;
+
+ private RendererManager rendererManager;
+
+ @Before
+ public void init() {
+ rendererManager = new RendererManager(dataProvider);
+ }
+
+ /**
+ * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE--EP2
+ */
+ @Test
+ public void testResolveRendererPolicyForEndpoint_onePolicy() {
+ ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
+ PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
+ ResolvedPolicy resolvedPolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1).build();
+ ResolvedPolicies resolvedPolicies =
+ new ResolvedPoliciesBuilder().setResolvedPolicy(ImmutableList.of(resolvedPolicy)).build();
+ rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
+
+ AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
+ AddressEndpoint ep2 = TestDataFactory.defaultAdrEp(ADR_2, EPG_PURPLE).build();
+ Endpoints endpoints = new EndpointsBuilder()
+ .setAddressEndpoints(new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1, ep2)).build())
+ .build();
+ rendererManager.endpointsUpdated(endpoints);
+
+ AddressEndpointLocation ep1Loc = TestDataFactory.defaultAdrEpLoc(ep1.getKey(), REG_LOC_NODE_PATH_1).build();
+ AddressEndpointLocation ep2Loc = TestDataFactory.defaultAdrEpLoc(ep2.getKey(), REG_LOC_NODE_PATH_1).build();
+ EndpointLocations endpointLocations =
+ new EndpointLocationsBuilder().setAddressEndpointLocation(ImmutableList.of(ep1Loc, ep2Loc)).build();
+ rendererManager.endpointLocationsUpdated(endpointLocations);
+
+ RendererConfigurationBuilder rendererPolicyBuilder = new RendererConfigurationBuilder();
+ rendererManager.resolveRendererConfigForEndpoint(ep1, rendererPolicyBuilder);
+ ImmutableTable<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerEp =
+ rendererPolicyBuilder.getPoliciesByEpAndPeerEp();
+ assertFalse(policiesByEpAndPeerEp.isEmpty());
+ assertTrue(rendererPolicyBuilder.getPoliciesByEpAndPeerExtEp().isEmpty());
+ assertTrue(rendererPolicyBuilder.getPoliciesByEpAndPeerExtConEp().isEmpty());
+ assertEquals(1, policiesByEpAndPeerEp.rowKeySet().size());
+ assertEquals(1, policiesByEpAndPeerEp.columnKeySet().size());
+ // check EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE--EP2
+ RendererEndpointKey rendererEpKey = AddressEndpointUtils.toRendererEpKey(ep1.getKey());
+ assertEquals(rendererEpKey, policiesByEpAndPeerEp.rowKeySet().iterator().next());
+ PeerEndpointKey peerEpKey = AddressEndpointUtils.toPeerEpKey(ep2.getKey());
+ assertEquals(peerEpKey, policiesByEpAndPeerEp.columnKeySet().iterator().next());
+ Set<RuleGroupWithRendererEndpointParticipation> ruleGrpsWithEpPartic =
+ policiesByEpAndPeerEp.get(rendererEpKey, peerEpKey);
+ assertEquals(1, ruleGrpsWithEpPartic.size());
+ RuleGroupWithRendererEndpointParticipation ruleGrpWithEpPartic = ruleGrpsWithEpPartic.iterator().next();
+ assertEquals(ruleGrp1.getTenantId(), ruleGrpWithEpPartic.getTenantId());
+ assertEquals(ruleGrp1.getContractId(), ruleGrpWithEpPartic.getContractId());
+ assertEquals(ruleGrp1.getSubjectName(), ruleGrpWithEpPartic.getSubjectName());
+ assertEquals(EndpointPolicyParticipation.CONSUMER, ruleGrpWithEpPartic.getRendererEndpointParticipation());
+ }
+
+ /**
+ * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE--EP2
+ * <br>
+ * EP3--EPG_RED----SUBJECT_1---(P)EPG_GREY--EP4
+ */
+ @Test
+ public void testResolveRendererPolicyForEndpoint_onePolicyTwoUsage() {
+ ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
+ PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
+ ResolvedPolicy bluePurplePolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1).build();
+ ResolvedPolicy redGreyPolicy = TestDataFactory.defaultResolvedPolicy(EPG_RED, EPG_GREY, ruleGrp1).build();
+ ResolvedPolicies resolvedPolicies = new ResolvedPoliciesBuilder()
+ .setResolvedPolicy(ImmutableList.of(bluePurplePolicy, redGreyPolicy)).build();
+ rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
+
+ AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE).build();
+ AddressEndpoint ep2 = TestDataFactory.defaultAdrEp(ADR_2, EPG_PURPLE).build();
+ AddressEndpoint ep3 = TestDataFactory.defaultAdrEp(ADR_3, EPG_RED).build();
+ AddressEndpoint ep4 = TestDataFactory.defaultAdrEp(ADR_4, EPG_GREY).build();
+ Endpoints endpoints = new EndpointsBuilder()
+ .setAddressEndpoints(
+ new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1, ep2, ep3, ep4)).build())
+ .build();
+ rendererManager.endpointsUpdated(endpoints);
+
+ AddressEndpointLocation ep1Loc = TestDataFactory.defaultAdrEpLoc(ep1.getKey(), REG_LOC_NODE_PATH_1).build();
+ AddressEndpointLocation ep2Loc = TestDataFactory.defaultAdrEpLoc(ep2.getKey(), REG_LOC_NODE_PATH_1).build();
+ AddressEndpointLocation ep3Loc = TestDataFactory.defaultAdrEpLoc(ep3.getKey(), REG_LOC_NODE_PATH_1).build();
+ AddressEndpointLocation ep4Loc = TestDataFactory.defaultAdrEpLoc(ep4.getKey(), REG_LOC_NODE_PATH_1).build();
+ EndpointLocations endpointLocations = new EndpointLocationsBuilder()
+ .setAddressEndpointLocation(ImmutableList.of(ep1Loc, ep2Loc, ep3Loc, ep4Loc)).build();
+ rendererManager.endpointLocationsUpdated(endpointLocations);
+
+ // EP1, EP3 as renderer endpoints
+ RendererConfigurationBuilder rendererPolicyBuilder = new RendererConfigurationBuilder();
+ rendererManager.resolveRendererConfigForEndpoint(ep1, rendererPolicyBuilder);
+ rendererManager.resolveRendererConfigForEndpoint(ep3, rendererPolicyBuilder);
+ ImmutableTable<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerEp =
+ rendererPolicyBuilder.getPoliciesByEpAndPeerEp();
+ assertFalse(policiesByEpAndPeerEp.isEmpty());
+ assertTrue(rendererPolicyBuilder.getPoliciesByEpAndPeerExtEp().isEmpty());
+ assertTrue(rendererPolicyBuilder.getPoliciesByEpAndPeerExtConEp().isEmpty());
+ assertEquals(2, policiesByEpAndPeerEp.rowKeySet().size());
+ assertEquals(2, policiesByEpAndPeerEp.columnKeySet().size());
+ // check EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE
+ RendererEndpointKey ep1RendererEpKey = AddressEndpointUtils.toRendererEpKey(ep1.getKey());
+ assertTrue(policiesByEpAndPeerEp.containsRow(ep1RendererEpKey));
+ PeerEndpointKey ep2PeerEpKey = AddressEndpointUtils.toPeerEpKey(ep2.getKey());
+ assertTrue(policiesByEpAndPeerEp.containsColumn(ep2PeerEpKey));
+ Set<RuleGroupWithRendererEndpointParticipation> ep1Ep2RuleGrpsWithEpPartic =
+ policiesByEpAndPeerEp.get(ep1RendererEpKey, ep2PeerEpKey);
+ assertEquals(1, ep1Ep2RuleGrpsWithEpPartic.size());
+ RuleGroupWithRendererEndpointParticipation ruleGrp1WithEpPartic = ep1Ep2RuleGrpsWithEpPartic.iterator().next();
+ assertEquals(ruleGrp1.getTenantId(), ruleGrp1WithEpPartic.getTenantId());
+ assertEquals(ruleGrp1.getContractId(), ruleGrp1WithEpPartic.getContractId());
+ assertEquals(ruleGrp1.getSubjectName(), ruleGrp1WithEpPartic.getSubjectName());
+ assertEquals(EndpointPolicyParticipation.CONSUMER, ruleGrp1WithEpPartic.getRendererEndpointParticipation());
+ // check EP3--EPG_RED----SUBJECT_1---(P)EPG_GREY--EP4
+ RendererEndpointKey ep3RendererEpKey = AddressEndpointUtils.toRendererEpKey(ep3.getKey());
+ assertTrue(policiesByEpAndPeerEp.containsRow(ep3RendererEpKey));
+ PeerEndpointKey ep4PeerEpKey = AddressEndpointUtils.toPeerEpKey(ep4.getKey());
+ assertTrue(policiesByEpAndPeerEp.containsColumn(ep4PeerEpKey));
+ Set<RuleGroupWithRendererEndpointParticipation> ep3Ep4RuleGrpsWithEpPartic =
+ policiesByEpAndPeerEp.get(ep3RendererEpKey, ep4PeerEpKey);
+ assertEquals(1, ep3Ep4RuleGrpsWithEpPartic.size());
+ ruleGrp1WithEpPartic = ep3Ep4RuleGrpsWithEpPartic.iterator().next();
+ assertEquals(ruleGrp1.getTenantId(), ruleGrp1WithEpPartic.getTenantId());
+ assertEquals(ruleGrp1.getContractId(), ruleGrp1WithEpPartic.getContractId());
+ assertEquals(ruleGrp1.getSubjectName(), ruleGrp1WithEpPartic.getSubjectName());
+ assertEquals(EndpointPolicyParticipation.CONSUMER, ruleGrp1WithEpPartic.getRendererEndpointParticipation());
+ }
+
+ /**
+ * EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE--EP2
+ * <br>
+ * EP1--EPG_RED----SUBJECT_2---(P)EPG_GREY--EP2,EP3
+ */
+ @Test
+ public void testResolveRendererPolicyForEndpoint_twoPolicy() {
+ ResolvedRule rule1 = TestDataFactory.defaultResolvedRule(RULE_1).build();
+ PolicyRuleGroup ruleGrp1 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_1, SUBJECT_1, rule1).build();
+ PolicyRuleGroup ruleGrp2 = TestDataFactory.defaultPolicyRuleGrp(CONTRACT_2, SUBJECT_2, rule1).build();
+ ResolvedPolicy bluePurplePolicy = TestDataFactory.defaultResolvedPolicy(EPG_BLUE, EPG_PURPLE, ruleGrp1).build();
+ ResolvedPolicy redGreyPolicy = TestDataFactory.defaultResolvedPolicy(EPG_RED, EPG_GREY, ruleGrp2).build();
+ ResolvedPolicies resolvedPolicies = new ResolvedPoliciesBuilder()
+ .setResolvedPolicy(ImmutableList.of(bluePurplePolicy, redGreyPolicy)).build();
+ rendererManager.resolvedPoliciesUpdated(resolvedPolicies);
+
+ AddressEndpoint ep1 = TestDataFactory.defaultAdrEp(ADR_1, EPG_BLUE, EPG_RED).build();
+ AddressEndpoint ep2 = TestDataFactory.defaultAdrEp(ADR_2, EPG_PURPLE, EPG_GREY).build();
+ AddressEndpoint ep3 = TestDataFactory.defaultAdrEp(ADR_3, EPG_GREY).build();
+ Endpoints endpoints =
+ new EndpointsBuilder()
+ .setAddressEndpoints(
+ new AddressEndpointsBuilder().setAddressEndpoint(ImmutableList.of(ep1, ep2, ep3)).build())
+ .build();
+ rendererManager.endpointsUpdated(endpoints);
+
+ AddressEndpointLocation ep1Loc = TestDataFactory.defaultAdrEpLoc(ep1.getKey(), REG_LOC_NODE_PATH_1).build();
+ AddressEndpointLocation ep2Loc = TestDataFactory.defaultAdrEpLoc(ep2.getKey(), REG_LOC_NODE_PATH_1).build();
+ AddressEndpointLocation ep3Loc = TestDataFactory.defaultAdrEpLoc(ep3.getKey(), REG_LOC_NODE_PATH_1).build();
+ EndpointLocations endpointLocations = new EndpointLocationsBuilder()
+ .setAddressEndpointLocation(ImmutableList.of(ep1Loc, ep2Loc, ep3Loc)).build();
+ rendererManager.endpointLocationsUpdated(endpointLocations);
+
+ // EP1 as renderer endpoint
+ RendererConfigurationBuilder rendererPolicyBuilder = new RendererConfigurationBuilder();
+ rendererManager.resolveRendererConfigForEndpoint(ep1, rendererPolicyBuilder);
+ ImmutableTable<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerEp =
+ rendererPolicyBuilder.getPoliciesByEpAndPeerEp();
+ assertFalse(policiesByEpAndPeerEp.isEmpty());
+ assertTrue(rendererPolicyBuilder.getPoliciesByEpAndPeerExtEp().isEmpty());
+ assertTrue(rendererPolicyBuilder.getPoliciesByEpAndPeerExtConEp().isEmpty());
+ assertEquals(1, policiesByEpAndPeerEp.rowKeySet().size());
+ assertEquals(2, policiesByEpAndPeerEp.columnKeySet().size());
+ // check EP1--EPG_BLUE---SUBJECT_1---(P)EPG_PURPLE--EP2
+ // check EP1--EPG_RED----SUBJECT_2---(P)EPG_GREY--EP2
+ RendererEndpointKey ep1RendererEpKey = AddressEndpointUtils.toRendererEpKey(ep1.getKey());
+ assertTrue(policiesByEpAndPeerEp.containsRow(ep1RendererEpKey));
+ PeerEndpointKey ep2PeerEpKey = AddressEndpointUtils.toPeerEpKey(ep2.getKey());
+ assertTrue(policiesByEpAndPeerEp.containsColumn(ep2PeerEpKey));
+ Set<RuleGroupWithRendererEndpointParticipation> ep1Ep2RuleGrpsWithEpPartic =
+ policiesByEpAndPeerEp.get(ep1RendererEpKey, ep2PeerEpKey);
+ assertEquals(2, ep1Ep2RuleGrpsWithEpPartic.size());
+ assertTrue(ep1Ep2RuleGrpsWithEpPartic.contains(RendererConfigurationBuilder
+ .toRuleGroupWithRendererEndpointParticipation(ruleGrp1.getKey(), EndpointPolicyParticipation.CONSUMER)));
+ assertTrue(ep1Ep2RuleGrpsWithEpPartic.contains(RendererConfigurationBuilder
+ .toRuleGroupWithRendererEndpointParticipation(ruleGrp2.getKey(), EndpointPolicyParticipation.CONSUMER)));
+ // check EP1--EPG_RED----SUBJECT_2---(P)EPG_GREY--EP3
+ PeerEndpointKey ep3PeerEpKey = AddressEndpointUtils.toPeerEpKey(ep3.getKey());
+ assertTrue(policiesByEpAndPeerEp.containsColumn(ep3PeerEpKey));
+ Set<RuleGroupWithRendererEndpointParticipation> ep1Ep3RuleGrpsWithEpPartic =
+ policiesByEpAndPeerEp.get(ep1RendererEpKey, ep3PeerEpKey);
+ assertEquals(1, ep1Ep3RuleGrpsWithEpPartic.size());
+ assertTrue(ep1Ep3RuleGrpsWithEpPartic.contains(RendererConfigurationBuilder
+ .toRuleGroupWithRendererEndpointParticipation(ruleGrp2.getKey(), EndpointPolicyParticipation.CONSUMER)));
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.groupbasedpolicy.renderer;
+
+import java.util.Arrays;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.ForwardingContextContainmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.LocationType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.RelativeLocationsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.Action;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.ActionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRule;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRuleBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraintsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
+
+import com.google.common.collect.ImmutableList;
+
+public class TestDataFactory {
+
+ public static final TenantId TENANT_ID = new TenantId("cisco_tenant");
+ public static final ActionDefinitionId AD_1 = new ActionDefinitionId("ad_1");
+ public static final ActionName AN_1 = new ActionName("an_1");
+ public static final ClassifierDefinitionId CD_1 = new ClassifierDefinitionId("cd_1");
+ public static final ClassifierName CN_1 = new ClassifierName("cn_1");
+ public static final ContextId CTX_1 = new ContextId("ctx_1");
+
+ public static AddressEndpointLocationBuilder defaultAdrEpLoc(AddressEndpointKey adrEpKey, LocationType realLoc,
+ InternalLocation... relativeLocs) {
+ AddressEndpointLocationBuilder result =
+ new AddressEndpointLocationBuilder().setContextType(adrEpKey.getContextType())
+ .setContextId(adrEpKey.getContextId())
+ .setAddressType(adrEpKey.getAddressType())
+ .setAddress(adrEpKey.getAddress())
+ .setAbsoluteLocation(new AbsoluteLocationBuilder().setLocationType(realLoc).build());
+ if (relativeLocs != null) {
+ result.setRelativeLocations(
+ new RelativeLocationsBuilder().setInternalLocation(Arrays.asList(relativeLocs)).build());
+ }
+ return result;
+ }
+
+ public static ContainmentEndpointLocationBuilder defaultContEpLoc(ContainmentEndpointKey contEpKey,
+ InternalLocation... relativeLocs) {
+ ContainmentEndpointLocationBuilder result = new ContainmentEndpointLocationBuilder()
+ .setContextType(contEpKey.getContextType()).setContextId(contEpKey.getContextId()).setRelativeLocations(
+ new RelativeLocationsBuilder().setInternalLocation(Arrays.asList(relativeLocs)).build());
+ return result;
+ }
+
+ public static AddressEndpointBuilder defaultAdrEp(String address, EndpointGroupId... epgs) {
+ return new AddressEndpointBuilder().setContextType(DummyContextType.class)
+ .setContextId(CTX_1)
+ .setAddressType(DummyAddressType.class)
+ .setAddress(address)
+ .setTenant(TENANT_ID)
+ .setEndpointGroup(Arrays.asList(epgs))
+ .setNetworkContainment(
+ new NetworkContainmentBuilder().setContainment(new ForwardingContextContainmentBuilder()
+ .setContextType(DummyContextType.class).setContextId(CTX_1).build()).build());
+ }
+
+ public static ContainmentEndpointBuilder defaultContEp(EndpointGroupId... epgs) {
+ return new ContainmentEndpointBuilder().setContextType(DummyContextType.class)
+ .setContextId(CTX_1)
+ .setTenant(TENANT_ID)
+ .setEndpointGroup(Arrays.asList(epgs))
+ .setNetworkContainment(
+ new NetworkContainmentBuilder().setContainment(new ForwardingContextContainmentBuilder()
+ .setContextType(DummyContextType.class).setContextId(CTX_1).build()).build());
+ }
+
+ public static ResolvedRuleBuilder defaultResolvedRule(RuleName ruleName) {
+ Action action = new ActionBuilder().setActionDefinitionId(AD_1).setName(AN_1).setOrder(0).build();
+ Classifier classifier = new ClassifierBuilder().setClassifierDefinitionId(CD_1)
+ .setName(CN_1)
+ .setDirection(Direction.In)
+ .build();
+ return new ResolvedRuleBuilder().setName(ruleName)
+ .setOrder(0)
+ .setAction(ImmutableList.of(action))
+ .setClassifier(ImmutableList.of(classifier));
+ }
+
+ public static PolicyRuleGroupBuilder defaultPolicyRuleGrp(ContractId contractId, SubjectName subjectName,
+ ResolvedRule... resolvedRules) {
+ return new PolicyRuleGroupBuilder().setTenantId(TENANT_ID)
+ .setContractId(contractId)
+ .setSubjectName(subjectName)
+ .setResolvedRule(Arrays.asList(resolvedRules));
+ }
+
+ public static ResolvedPolicyBuilder defaultResolvedPolicy(EndpointGroupId consEpg, EndpointGroupId provEpg,
+ PolicyRuleGroup... policyRuleGrps) {
+ PolicyRuleGroupWithEndpointConstraints blueRuleGrpWithoutCons =
+ new PolicyRuleGroupWithEndpointConstraintsBuilder().setPolicyRuleGroup(Arrays.asList(policyRuleGrps))
+ .build();
+ return new ResolvedPolicyBuilder().setConsumerEpgId(consEpg)
+ .setConsumerTenantId(TENANT_ID)
+ .setProviderEpgId(provEpg)
+ .setProviderTenantId(TENANT_ID)
+ .setPolicyRuleGroupWithEndpointConstraints(ImmutableList.of(blueRuleGrpWithoutCons));
+ }
+
+ public static abstract class DummyContextType extends ContextType {
+ };
+ public static abstract class DummyAddressType extends AddressType {
+ };
+}
/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
package org.opendaylight.groupbasedpolicy.resolver;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import java.util.Collections;
import java.util.Set;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.groupbasedpolicy.dto.ConditionGroup;
private ConditionGroup conditionGroup;
private ConditionSet conditionSet;
- private Set<ConditionSet> conditionSetSet;
@Before
- public void initialisation() {
+ public void init() {
conditionSet = mock(ConditionSet.class);
- conditionSetSet = Collections.singleton(conditionSet);
-
- conditionGroup = new ConditionGroup(conditionSetSet);
+ conditionGroup = new ConditionGroup(Collections.singleton(conditionSet));
}
@Test
- public void constructorTest() {
- Assert.assertTrue(conditionGroup.contains(conditionSet));
+ public void testConstructor() {
+ assertTrue(conditionGroup.contains(conditionSet));
}
@Test
- public void equalsTest() {
- Assert.assertTrue(conditionGroup.equals(conditionGroup));
- Assert.assertFalse(conditionGroup.equals(null));
- Assert.assertFalse(conditionGroup.equals(new Object()));
+ public void testEquals() {
+ assertTrue(conditionGroup.equals(conditionGroup));
+ assertFalse(conditionGroup.equals(null));
+ assertFalse(conditionGroup.equals(new Object()));
ConditionSet conditionSet = mock(ConditionSet.class);
Set<ConditionSet> conditionSetSetOther = Collections.singleton(conditionSet);
ConditionGroup other;
other = new ConditionGroup(conditionSetSetOther);
- Assert.assertFalse(conditionGroup.equals(other));
+ assertFalse(conditionGroup.equals(other));
}
@Test
- public void toStringTest() {
- Assert.assertNotNull(conditionGroup.toString());
+ public void testToString() {
+ assertNotNull(conditionGroup.toString());
}
}
/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
package org.opendaylight.groupbasedpolicy.resolver;
-import static org.mockito.Mockito.mock;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
-import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.groupbasedpolicy.dto.ConditionSet;
public class ConditionSetTest {
- private ConditionSet conditionSet;
+ private static final String CONDITION1 = "condition1";
+ private static final String CONDITION2 = "condition2";
+ private ConditionSet conditionSet;
private ConditionName conditionName;
private Set<ConditionName> conditionNameSet;
private Set<Set<ConditionName>> anySet;
@Before
- public void initialisation() {
- conditionName = mock(ConditionName.class);
+ public void init() {
+ conditionName = new ConditionName(CONDITION1);
conditionNameSet = Collections.singleton(conditionName);
anySet = Collections.singleton(conditionNameSet);
conditionSet = new ConditionSet(conditionNameSet, conditionNameSet, anySet);
}
@Test
- public void matchesTest() {
- List<ConditionName> conditionNameList;
- conditionNameList = Arrays.asList(conditionName);
- Assert.assertFalse(conditionSet.matches(conditionNameList));
-
- ConditionName conditionNameOther;
- conditionNameOther = mock(ConditionName.class);
- conditionNameList = Arrays.asList(conditionNameOther);
- Assert.assertFalse(conditionSet.matches(conditionNameList));
+ public void testMatches() {
+ List<ConditionName> conditionNameList = Collections.singletonList(conditionName);
+ assertFalse(conditionSet.matches(conditionNameList));
+
+ ConditionName conditionNameOther = new ConditionName(CONDITION2);
+ conditionNameList = Collections.singletonList(conditionNameOther);
+ assertFalse(conditionSet.matches(conditionNameList));
}
@Test
- public void equalsTest() {
- Assert.assertTrue(conditionSet.equals(conditionSet));
- Assert.assertFalse(conditionSet.equals(null));
- Assert.assertFalse(conditionSet.equals(new Object()));
+ public void testEquals() {
+ assertTrue(conditionSet.equals(conditionSet));
+ assertFalse(conditionSet.equals(null));
+ assertFalse(conditionSet.equals(new Object()));
ConditionSet other;
other = ConditionSet.EMPTY;
- Assert.assertFalse(conditionSet.equals(other));
+ assertFalse(conditionSet.equals(other));
other = new ConditionSet(conditionNameSet, Collections.<ConditionName>emptySet(),
Collections.<Set<ConditionName>>emptySet());
- Assert.assertFalse(conditionSet.equals(other));
+ assertFalse(conditionSet.equals(other));
other = new ConditionSet(conditionNameSet, Collections.<ConditionName>emptySet(), anySet);
- Assert.assertFalse(conditionSet.equals(other));
+ assertFalse(conditionSet.equals(other));
other = new ConditionSet(conditionNameSet, conditionNameSet, anySet);
- Assert.assertTrue(conditionSet.equals(other));
+ assertTrue(conditionSet.equals(other));
}
@Test
- public void toStringTest() {
- Assert.assertNotNull(conditionSet.toString());
+ public void testToString() {
+ assertNotNull(conditionSet.toString());
}
}
package org.opendaylight.groupbasedpolicy.resolver;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.groupbasedpolicy.dto.EgKey;
private EgKey egKey;
private TenantId tenantId;
private EndpointGroupId egId;
- private String value;
@Before
- public void initialisation() {
+ public void init() {
tenantId = mock(TenantId.class);
egId = mock(EndpointGroupId.class);
- value = "value";
+ String value = "value";
when(tenantId.getValue()).thenReturn(value);
when(egId.getValue()).thenReturn(value);
}
@Test
- public void constructorTest() {
- Assert.assertEquals(tenantId, egKey.getTenantId());
- Assert.assertEquals(egId, egKey.getEgId());
+ public void testConstructor() {
+ assertEquals(tenantId, egKey.getTenantId());
+ assertEquals(egId, egKey.getEgId());
}
@Test
- public void equalsTest() {
- Assert.assertTrue(egKey.equals(egKey));
- Assert.assertFalse(egKey.equals(null));
- Assert.assertFalse(egKey.equals(new Object()));
+ public void testEquals() {
+ assertTrue(egKey.equals(egKey));
+ assertFalse(egKey.equals(null));
+ assertFalse(egKey.equals(new Object()));
EgKey other;
other = new EgKey(null, egId);
- Assert.assertFalse(egKey.equals(other));
- Assert.assertFalse(other.equals(egKey));
+ assertFalse(egKey.equals(other));
+ assertFalse(other.equals(egKey));
other = new EgKey(tenantId, null);
- Assert.assertFalse(egKey.equals(other));
- Assert.assertFalse(other.equals(egKey));
+ assertFalse(egKey.equals(other));
+ assertFalse(other.equals(egKey));
other = new EgKey(tenantId, egId);
- Assert.assertTrue(egKey.equals(other));
+ assertTrue(egKey.equals(other));
egKey = new EgKey(null, null);
other = new EgKey(null, null);
- Assert.assertTrue(egKey.equals(other));
+ assertTrue(egKey.equals(other));
}
@Test
- public void compareToTest() {
+ public void testCompareTo() {
EgKey other = new EgKey(tenantId, egId);
- Assert.assertEquals(0, egKey.compareTo(other));
+ assertEquals(0, egKey.compareTo(other));
other = new EgKey(null, null);
- Assert.assertEquals(-1, egKey.compareTo(other));
- Assert.assertEquals(1, other.compareTo(egKey));
+ assertEquals(-1, egKey.compareTo(other));
+ assertEquals(1, other.compareTo(egKey));
String valueOther = "valu";
TenantId tenantIdOther = mock(TenantId.class);
when(tenantIdOther.getValue()).thenReturn(valueOther);
+
other = new EgKey(tenantIdOther, egId);
- Assert.assertEquals(1, egKey.compareTo(other));
- Assert.assertEquals(-1, other.compareTo(egKey));
+ assertEquals(1, egKey.compareTo(other));
+ assertEquals(-1, other.compareTo(egKey));
EndpointGroupId egIdOther = mock(EndpointGroupId.class);
when(egIdOther.getValue()).thenReturn(valueOther);
+
other = new EgKey(tenantId, egIdOther);
- Assert.assertEquals(1, egKey.compareTo(other));
- Assert.assertEquals(-1, other.compareTo(egKey));
+ assertEquals(1, egKey.compareTo(other));
+ assertEquals(-1, other.compareTo(egKey));
egKey = new EgKey(tenantIdOther, egId);
- Assert.assertEquals(-1, egKey.compareTo(other));
- Assert.assertEquals(1, other.compareTo(egKey));
+ assertEquals(-1, egKey.compareTo(other));
+ assertEquals(1, other.compareTo(egKey));
}
@Test
- public void toStringTest() {
+ public void testToString() {
String string = egKey.toString();
- Assert.assertNotNull(string);
- Assert.assertFalse(string.isEmpty());
- Assert.assertTrue(string.contains(tenantId.toString()));
- Assert.assertTrue(string.contains(egId.toString()));
+ assertNotNull(string);
+ assertFalse(string.isEmpty());
+ assertTrue(string.contains(tenantId.toString()));
+ assertTrue(string.contains(egId.toString()));
}
}
package org.opendaylight.groupbasedpolicy.resolver;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import java.util.Arrays;
+import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.groupbasedpolicy.dto.ConditionSet;
import org.opendaylight.groupbasedpolicy.dto.EndpointConstraint;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ConditionName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.EndpointIdentificationConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.EndpointIdentificationConstraintsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.L3EndpointIdentificationConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.L3EndpointIdentificationConstraintsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.l3.endpoint.identification.constraints.PrefixConstraint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.l3.endpoint.identification.constraints.PrefixConstraintBuilder;
public class EndpointConstraintTest {
private EndpointIdentificationConstraints consEpIdentificationConstraint;
private L3EndpointIdentificationConstraints l3Constraints;
private PrefixConstraint prefixConstraint;
+ private IpPrefix ipPrefix;
@Before
- public void initialise() {
+ public void init() {
conditionSet = mock(ConditionSet.class);
- consEpIdentificationConstraint = mock(EndpointIdentificationConstraints.class);
- l3Constraints = mock(L3EndpointIdentificationConstraints.class);
- when(consEpIdentificationConstraint.getL3EndpointIdentificationConstraints()).thenReturn(l3Constraints);
- prefixConstraint = mock(PrefixConstraint.class);
- when(l3Constraints.getPrefixConstraint()).thenReturn(Arrays.asList(prefixConstraint));
+
+ ipPrefix = new IpPrefix(new Ipv4Prefix("10.0.0.0/8"));
+ prefixConstraint = new PrefixConstraintBuilder().setIpPrefix(ipPrefix).build();
+ l3Constraints = new L3EndpointIdentificationConstraintsBuilder().setPrefixConstraint(
+ Collections.singletonList(prefixConstraint)).build();
+ consEpIdentificationConstraint =
+ new EndpointIdentificationConstraintsBuilder().setL3EndpointIdentificationConstraints(
+ l3Constraints).build();
constraint = new EndpointConstraint(conditionSet, consEpIdentificationConstraint);
}
@Test
- public void conditionsMatchTest() {
- ConditionName conditionName = mock(ConditionName.class);
- List<ConditionName> epConditions = Arrays.asList(conditionName);
- when(conditionSet.matches(epConditions)).thenReturn(true);
- Assert.assertTrue(constraint.conditionsMatch(epConditions));
+ public void testConstructor() {
+ assertEquals(conditionSet, constraint.getConditionSet());
+ assertTrue(constraint.getL3EpPrefixes().contains(prefixConstraint));
+ assertNotNull(constraint.hashCode());
+
+ constraint = new EndpointConstraint(null, consEpIdentificationConstraint);
+ assertEquals(ConditionSet.EMPTY, constraint.getConditionSet());
}
@Test
- public void constructorTest() {
- Assert.assertEquals(conditionSet, constraint.getConditionSet());
- Assert.assertTrue(constraint.getL3EpPrefixes().contains(prefixConstraint));
- Assert.assertNotNull(constraint.hashCode());
+ public void testConditionsMatch() {
+ ConditionName conditionName = new ConditionName("condition1");
+ List<ConditionName> epConditions = Collections.singletonList(conditionName);
+ when(conditionSet.matches(epConditions)).thenReturn(true);
- constraint = new EndpointConstraint(null, consEpIdentificationConstraint);
- Assert.assertEquals(ConditionSet.EMPTY, constraint.getConditionSet());
+ assertTrue(constraint.conditionsMatch(epConditions));
}
+
@Test
- public void getIpPrefixesFromTest() {
- PrefixConstraint prefixConstraint = mock(PrefixConstraint.class);
- IpPrefix ipPrefix = mock(IpPrefix.class);
- when(prefixConstraint.getIpPrefix()).thenReturn(ipPrefix);
- Set<PrefixConstraint> prefixConstraints = new HashSet<PrefixConstraint>();
+ public void testGetIpPrefixesFrom() {
+ Set<PrefixConstraint> prefixConstraints = new HashSet<>();
prefixConstraints.add(prefixConstraint);
Set<IpPrefix> ipPrefixes = EndpointConstraint.getIpPrefixesFrom(prefixConstraints);
- Assert.assertEquals(1, ipPrefixes.size());
- Assert.assertTrue(ipPrefixes.contains(ipPrefix));
+
+ assertEquals(1, ipPrefixes.size());
+ assertTrue(ipPrefixes.contains(ipPrefix));
}
@Test
- public void equalsTest() {
- Assert.assertTrue(constraint.equals(constraint));
- Assert.assertFalse(constraint.equals(null));
- Assert.assertFalse(constraint.equals(new Object()));
+ public void testEquals() {
+ assertTrue(constraint.equals(constraint));
+ assertFalse(constraint.equals(null));
+ assertFalse(constraint.equals(new Object()));
EndpointConstraint other;
ConditionSet conditionSetOther = mock(ConditionSet.class);
EndpointIdentificationConstraints consEpIdentificationConstraintOther = mock(EndpointIdentificationConstraints.class);
other = new EndpointConstraint(conditionSet, consEpIdentificationConstraintOther);
- Assert.assertFalse(constraint.equals(other));
+ assertFalse(constraint.equals(other));
other = new EndpointConstraint(conditionSetOther, consEpIdentificationConstraint);
- Assert.assertFalse(constraint.equals(other));
+ assertFalse(constraint.equals(other));
other = new EndpointConstraint(conditionSet, consEpIdentificationConstraint);
- Assert.assertTrue(constraint.equals(other));
+ assertTrue(constraint.equals(other));
}
}
package org.opendaylight.groupbasedpolicy.resolver;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
import org.junit.Before;
import org.junit.Rule;
/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.HashSet;
import java.util.List;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import org.junit.Test;
import org.opendaylight.groupbasedpolicy.util.InheritanceUtils;
import org.opendaylight.groupbasedpolicy.util.TenantUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderTargetSelector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderTargetSelectorBuilder;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-
public class InheritanceUtilsTest {
// ******
// Labels
// ******
- Quality q1 = new QualityBuilder()
- .setName(new QualityName("q1"))
- .build();
- Quality q1Include = new QualityBuilder(q1)
- .setInclusionRule(InclusionRule.Include)
- .build();
- Quality q1Exclude = new QualityBuilder(q1)
- .setInclusionRule(InclusionRule.Exclude)
- .build();
- Quality q2 = new QualityBuilder()
- .setName(new QualityName("q2"))
- .build();
- Quality q2Exclude = new QualityBuilder()
- .setName(new QualityName("q2"))
- .setInclusionRule(InclusionRule.Exclude)
- .build();
- Quality q3 = new QualityBuilder()
- .setName(new QualityName("q3"))
- .build();
-
- Requirement r1 = new RequirementBuilder()
- .setName(new RequirementName("r1"))
- .build();
- Requirement r2 = new RequirementBuilder()
- .setName(new RequirementName("r2"))
- .build();
- Requirement r1exclude = new RequirementBuilder()
- .setName(new RequirementName("r1"))
- .setInclusionRule(InclusionRule.Exclude)
- .build();
- Requirement r3 = new RequirementBuilder()
- .setName(new RequirementName("r3"))
- .build();
-
- Capability c1 = new CapabilityBuilder()
- .setName(new CapabilityName("c1"))
- .build();
- Capability c2 = new CapabilityBuilder()
- .setName(new CapabilityName("c2"))
- .build();
- Capability c1exclude = new CapabilityBuilder()
- .setName(new CapabilityName("c1"))
- .setInclusionRule(InclusionRule.Exclude)
- .build();
- Capability c3 = new CapabilityBuilder()
- .setName(new CapabilityName("c3"))
- .build();
-
- Condition cond1 = new ConditionBuilder()
- .setName(new ConditionName("cond1"))
- .build();
- Condition cond2 = new ConditionBuilder()
- .setName(new ConditionName("cond2"))
- .build();
- Condition cond2exlude = new ConditionBuilder()
- .setName(new ConditionName("cond2"))
- .setInclusionRule(InclusionRule.Exclude)
- .build();
+ Quality q1 = new QualityBuilder().setName(new QualityName("q1")).build();
+ Quality q1Include = new QualityBuilder(q1).setInclusionRule(InclusionRule.Include).build();
+ Quality q1Exclude = new QualityBuilder(q1).setInclusionRule(InclusionRule.Exclude).build();
+ Quality q2 = new QualityBuilder().setName(new QualityName("q2")).build();
+ Quality q2Exclude =
+ new QualityBuilder().setName(new QualityName("q2")).setInclusionRule(InclusionRule.Exclude).build();
+ Quality q3 = new QualityBuilder().setName(new QualityName("q3")).build();
+
+ Requirement r1 = new RequirementBuilder().setName(new RequirementName("r1")).build();
+ Requirement r2 = new RequirementBuilder().setName(new RequirementName("r2")).build();
+ Requirement r1exclude =
+ new RequirementBuilder().setName(new RequirementName("r1")).setInclusionRule(InclusionRule.Exclude).build();
+ Requirement r3 = new RequirementBuilder().setName(new RequirementName("r3")).build();
+
+ Capability c1 = new CapabilityBuilder().setName(new CapabilityName("c1")).build();
+ Capability c2 = new CapabilityBuilder().setName(new CapabilityName("c2")).build();
+ Capability c1exclude =
+ new CapabilityBuilder().setName(new CapabilityName("c1")).setInclusionRule(InclusionRule.Exclude).build();
+ Capability c3 = new CapabilityBuilder().setName(new CapabilityName("c3")).build();
+
+ Condition cond1 = new ConditionBuilder().setName(new ConditionName("cond1")).build();
+ Condition cond2 = new ConditionBuilder().setName(new ConditionName("cond2")).build();
+ Condition cond2exlude =
+ new ConditionBuilder().setName(new ConditionName("cond2")).setInclusionRule(InclusionRule.Exclude).build();
// *********
// Contracts
// *********
TargetName q2TargetName = new TargetName("q2");
- Target q2Target = new TargetBuilder()
- .setName(q2TargetName)
- .setQuality(ImmutableList.of(q2))
- .build();
+ Target q2Target = new TargetBuilder().setName(q2TargetName).setQuality(ImmutableList.of(q2)).build();
TargetName q1ExcludeTargetName = new TargetName("q1_exclude");
- Target q1ExcludeTarget = new TargetBuilder()
- .setName(q1ExcludeTargetName)
- .setQuality(ImmutableList.of(q1Exclude, q2))
- .build();
+ Target q1ExcludeTarget =
+ new TargetBuilder().setName(q1ExcludeTargetName).setQuality(ImmutableList.of(q1Exclude, q2)).build();
TargetName q1IncludeTargetName = new TargetName("q1_include");
- Target q1IncludeTarget = new TargetBuilder()
- .setName(q1IncludeTargetName)
- .setQuality(ImmutableList.of(q1Include))
- .build();
+ Target q1IncludeTarget =
+ new TargetBuilder().setName(q1IncludeTargetName).setQuality(ImmutableList.of(q1Include)).build();
- Target q2PlusTarget = new TargetBuilder()
- .setName(q2TargetName)
- .setQuality(ImmutableList.of(q3))
- .build();
+ Target q2PlusTarget = new TargetBuilder().setName(q2TargetName).setQuality(ImmutableList.of(q3)).build();
SubjectName subject1 = new SubjectName("subject1");
SubjectName subject2 = new SubjectName("subject2");
SubjectName subject3 = new SubjectName("subject3");
- RequirementMatcher rm_r1 = new RequirementMatcherBuilder()
- .setName(new RequirementMatcherName("rm_r1"))
- .setMatcherRequirement(ImmutableList.of(new MatcherRequirementBuilder(r1)
- .build()))
+ RequirementMatcher rm_r1 = new RequirementMatcherBuilder().setName(new RequirementMatcherName("rm_r1"))
+ .setMatcherRequirement(ImmutableList.of(new MatcherRequirementBuilder(r1).build()))
.build();
- RequirementMatcher rm_r1_plus = new RequirementMatcherBuilder()
- .setName(new RequirementMatcherName("rm_r1"))
+ RequirementMatcher rm_r1_plus = new RequirementMatcherBuilder().setName(new RequirementMatcherName("rm_r1"))
.setMatchType(MatchType.All)
- .setMatcherRequirement(ImmutableList.of(new MatcherRequirementBuilder(r2)
- .build()))
+ .setMatcherRequirement(ImmutableList.of(new MatcherRequirementBuilder(r2).build()))
.build();
- CapabilityMatcher capm_c1 = new CapabilityMatcherBuilder()
- .setName(new CapabilityMatcherName("capm_c1"))
- .setMatcherCapability(ImmutableList.of(new MatcherCapabilityBuilder(c1)
- .build()))
+ CapabilityMatcher capm_c1 = new CapabilityMatcherBuilder().setName(new CapabilityMatcherName("capm_c1"))
+ .setMatcherCapability(ImmutableList.of(new MatcherCapabilityBuilder(c1).build()))
.build();
- ConditionMatcher cm_c1 = new ConditionMatcherBuilder()
- .setName(new ConditionMatcherName("cm_c1"))
+ ConditionMatcher cm_c1 = new ConditionMatcherBuilder().setName(new ConditionMatcherName("cm_c1"))
.setCondition(ImmutableList.of(cond1))
.build();
- ConditionMatcher cm_c2 = new ConditionMatcherBuilder()
- .setName(new ConditionMatcherName("cm_c2"))
+ ConditionMatcher cm_c2 = new ConditionMatcherBuilder().setName(new ConditionMatcherName("cm_c2"))
.setMatchType(MatchType.All)
.setCondition(ImmutableList.of(cond2))
.build();
- ConditionMatcher cm_c2_plus = new ConditionMatcherBuilder()
- .setName(new ConditionMatcherName("cm_c2"))
+ ConditionMatcher cm_c2_plus = new ConditionMatcherBuilder().setName(new ConditionMatcherName("cm_c2"))
.setCondition(ImmutableList.of(cond2exlude))
.build();
ClauseName clauseName1 = new ClauseName("clauseName1");
- Clause clause1 = new ClauseBuilder()
- .setName(clauseName1)
- .setSubjectRefs(ImmutableList.of(subject1))
- .setProviderMatchers(new ProviderMatchersBuilder()
- .setGroupIdentificationConstraints(new GroupCapabilityConstraintCaseBuilder()
- .setCapabilityMatcher(ImmutableList.of(capm_c1)).build())
- .setConditionMatcher(ImmutableList.of(cm_c1))
- .build())
- .setConsumerMatchers(new ConsumerMatchersBuilder()
- .setGroupIdentificationConstraints(new GroupRequirementConstraintCaseBuilder()
- .setRequirementMatcher(ImmutableList.of(rm_r1)).build())
- .setConditionMatcher(ImmutableList.of(cm_c2))
- .build())
- .build();
-
- Clause clause1withConsMatcher = new ClauseBuilder()
- .setName(clauseName1)
+ Clause clause1 =
+ new ClauseBuilder().setName(clauseName1)
+ .setSubjectRefs(ImmutableList.of(subject1))
+ .setProviderMatchers(new ProviderMatchersBuilder()
+ .setGroupIdentificationConstraints(new GroupCapabilityConstraintCaseBuilder()
+ .setCapabilityMatcher(ImmutableList.of(capm_c1)).build())
+ .setConditionMatcher(ImmutableList.of(cm_c1))
+ .build())
+ .setConsumerMatchers(new ConsumerMatchersBuilder()
+ .setGroupIdentificationConstraints(new GroupRequirementConstraintCaseBuilder()
+ .setRequirementMatcher(ImmutableList.of(rm_r1)).build())
+ .setConditionMatcher(ImmutableList.of(cm_c2))
+ .build())
+ .build();
+
+ Clause clause1withConsMatcher = new ClauseBuilder().setName(clauseName1)
.setSubjectRefs(ImmutableList.of(subject2))
.setConsumerMatchers(new ConsumerMatchersBuilder()
- .setGroupIdentificationConstraints(new GroupRequirementConstraintCaseBuilder()
- .setRequirementMatcher(ImmutableList.of(rm_r1_plus)).build())
+ .setGroupIdentificationConstraints(new GroupRequirementConstraintCaseBuilder()
+ .setRequirementMatcher(ImmutableList.of(rm_r1_plus)).build())
.setConditionMatcher(ImmutableList.of(cm_c2_plus))
.build())
.build();
- Clause clause1withProvMatcher = new ClauseBuilder()
- .setName(clauseName1)
- .setSubjectRefs(ImmutableList.of(subject3))
- .setProviderMatchers(new ProviderMatchersBuilder()
- .setGroupIdentificationConstraints(new GroupCapabilityConstraintCaseBuilder()
- .setCapabilityMatcher(ImmutableList.of(capm_c1)).build())
- .setConditionMatcher(ImmutableList.of(cm_c2_plus))
- .build())
- .build();
-
- ActionRef a1 = new ActionRefBuilder()
- .setName(new ActionName("a1"))
- .build();
- ClassifierRef cr1 = new ClassifierRefBuilder()
- .setName(new ClassifierName("cr1"))
- .build();
- Rule rule1 = new RuleBuilder()
- .setName(new RuleName("r1"))
+ Clause clause1withProvMatcher =
+ new ClauseBuilder().setName(clauseName1)
+ .setSubjectRefs(ImmutableList.of(subject3))
+ .setProviderMatchers(new ProviderMatchersBuilder()
+ .setGroupIdentificationConstraints(new GroupCapabilityConstraintCaseBuilder()
+ .setCapabilityMatcher(ImmutableList.of(capm_c1)).build())
+ .setConditionMatcher(ImmutableList.of(cm_c2_plus))
+ .build())
+ .build();
+
+ ActionRef a1 = new ActionRefBuilder().setName(new ActionName("a1")).build();
+ ClassifierRef cr1 = new ClassifierRefBuilder().setName(new ClassifierName("cr1")).build();
+ Rule rule1 = new RuleBuilder().setName(new RuleName("r1"))
.setActionRef(ImmutableList.of(a1))
.setClassifierRef(ImmutableList.of(cr1))
.build();
- Rule rule2 = new RuleBuilder()
- .setName(new RuleName("r2"))
- .setOrder(5)
- .build();
- Rule rule3 = new RuleBuilder()
- .setName(new RuleName("r3"))
- .setOrder(7)
- .build();
- Rule rule4 = new RuleBuilder()
- .setName(new RuleName("r4"))
- .setOrder(1)
- .build();
+ Rule rule2 = new RuleBuilder().setName(new RuleName("r2")).setOrder(5).build();
+ Rule rule3 = new RuleBuilder().setName(new RuleName("r3")).setOrder(7).build();
+ Rule rule4 = new RuleBuilder().setName(new RuleName("r4")).setOrder(1).build();
- Subject s1 = new SubjectBuilder()
- .setName(new SubjectName("s1"))
- .setRule(ImmutableList.of(rule1, rule2))
- .build();
- Subject s1_plus = new SubjectBuilder()
- .setName(s1.getName())
- .setRule(ImmutableList.of(rule3, rule4))
- .setOrder(4)
- .build();
- Subject s2 = new SubjectBuilder()
- .setName(new SubjectName("s2"))
- .setOrder(5)
- .build();
- Subject s2_plus = new SubjectBuilder()
- .setName(new SubjectName(s2.getName()))
- .setOrder(6)
- .build();
-
- ContractId contractId1 =
- new ContractId("e7e6804f-7fcb-46cf-9bc6-abfec0896d95");
- Contract contract1 = new ContractBuilder()
- .setId(contractId1)
+ Subject s1 = new SubjectBuilder().setName(new SubjectName("s1")).setRule(ImmutableList.of(rule1, rule2)).build();
+ Subject s1_plus =
+ new SubjectBuilder().setName(s1.getName()).setRule(ImmutableList.of(rule3, rule4)).setOrder(4).build();
+ Subject s2 = new SubjectBuilder().setName(new SubjectName("s2")).setOrder(5).build();
+ Subject s2_plus = new SubjectBuilder().setName(new SubjectName(s2.getName())).setOrder(6).build();
+
+ ContractId contractId1 = new ContractId("e7e6804f-7fcb-46cf-9bc6-abfec0896d95");
+ Contract contract1 = new ContractBuilder().setId(contractId1)
.setQuality(ImmutableList.of(q1))
- .setTarget(ImmutableList.of(q2Target,
- q1IncludeTarget,
- q1ExcludeTarget))
+ .setTarget(ImmutableList.of(q2Target, q1IncludeTarget, q1ExcludeTarget))
.setClause(ImmutableList.of(clause1))
.setSubject(ImmutableList.of(s1))
.build();
- ContractId contractId2 =
- new ContractId("3f56ae44-d1e4-4617-95af-c809dfc50149");
- Contract contract2 = new ContractBuilder()
- .setId(contractId2)
+ ContractId contractId2 = new ContractId("3f56ae44-d1e4-4617-95af-c809dfc50149");
+ Contract contract2 = new ContractBuilder().setId(contractId2)
.setParent(contractId1)
.setTarget(ImmutableList.of(q2PlusTarget, q1IncludeTarget))
.setClause(ImmutableList.of(clause1withConsMatcher))
.setSubject(ImmutableList.of(s1_plus, s2))
.build();
- ContractId contractId3 =
- new ContractId("38d52ec1-301b-453a-88a6-3ffa777d7795");
- Contract contract3 = new ContractBuilder()
- .setId(contractId3)
+ ContractId contractId3 = new ContractId("38d52ec1-301b-453a-88a6-3ffa777d7795");
+ Contract contract3 = new ContractBuilder().setId(contractId3)
.setParent(contractId1)
.setTarget(ImmutableList.of(q2PlusTarget, q1IncludeTarget))
.setClause(ImmutableList.of(clause1withProvMatcher))
.build();
ContractId cloop2Id = new ContractId("89700928-7316-4216-a853-a7ea3934b8f4");
- Contract cloop1 = new ContractBuilder()
- .setId(new ContractId("56bbce36-e60b-473d-92de-bb63b5a6dbb5"))
+ Contract cloop1 = new ContractBuilder().setId(new ContractId("56bbce36-e60b-473d-92de-bb63b5a6dbb5"))
.setParent(cloop2Id)
.setClause(ImmutableList.of(clause1))
.setSubject(ImmutableList.of(s1, s2))
.build();
- Contract cloop2 = new ContractBuilder()
- .setId(cloop2Id)
- .setParent(cloop1.getId())
- .build();
- ContractId cselfloopid =
- new ContractId("63edead2-d6f1-4acf-9f78-831595d194ee");
- Contract cselfloop = new ContractBuilder()
- .setId(cselfloopid)
- .setParent(cselfloopid)
- .build();
- Contract corphan = new ContractBuilder()
- .setId(new ContractId("f72c15f3-76ab-4c7e-a817-eb5f6efcb654"))
+ Contract cloop2 = new ContractBuilder().setId(cloop2Id).setParent(cloop1.getId()).build();
+ ContractId cselfloopid = new ContractId("63edead2-d6f1-4acf-9f78-831595d194ee");
+ Contract cselfloop = new ContractBuilder().setId(cselfloopid).setParent(cselfloopid).build();
+ Contract corphan = new ContractBuilder().setId(new ContractId("f72c15f3-76ab-4c7e-a817-eb5f6efcb654"))
.setParent(new ContractId("eca4d0d5-8c62-4f46-ad42-71c1f4d3da12"))
.build();
// ***************
SelectorName cnsName1 = new SelectorName("cns1");
- ConsumerNamedSelector cns1 = new ConsumerNamedSelectorBuilder()
- .setName(cnsName1)
+ ConsumerNamedSelector cns1 = new ConsumerNamedSelectorBuilder().setName(cnsName1)
.setContract(ImmutableList.of(contractId1))
.setRequirement(ImmutableList.of(r2))
.build();
- ConsumerNamedSelector cns1_plus = new ConsumerNamedSelectorBuilder()
- .setName(cnsName1)
+ ConsumerNamedSelector cns1_plus = new ConsumerNamedSelectorBuilder().setName(cnsName1)
.setContract(ImmutableList.of(contractId2))
.setRequirement(ImmutableList.of(r3))
.build();
- ProviderNamedSelector pns1 = new ProviderNamedSelectorBuilder()
- .setName(cnsName1)
+ ProviderNamedSelector pns1 = new ProviderNamedSelectorBuilder().setName(cnsName1)
.setContract(ImmutableList.of(contractId1))
.setCapability(ImmutableList.of(c2))
.build();
- ProviderNamedSelector pns1_plus = new ProviderNamedSelectorBuilder()
- .setName(cnsName1)
+ ProviderNamedSelector pns1_plus = new ProviderNamedSelectorBuilder().setName(cnsName1)
.setContract(ImmutableList.of(contractId2))
.setCapability(ImmutableList.of(c3))
.build();
- QualityMatcher qm_q1_all = new QualityMatcherBuilder()
- .setName(new QualityMatcherName("qm_q1_all"))
- .setMatcherQuality(ImmutableList.of(new MatcherQualityBuilder(q1)
- .build()))
+ QualityMatcher qm_q1_all = new QualityMatcherBuilder().setName(new QualityMatcherName("qm_q1_all"))
+ .setMatcherQuality(ImmutableList.of(new MatcherQualityBuilder(q1).build()))
.setMatchType(MatchType.All)
.build();
- QualityMatcher qm_q1_any = new QualityMatcherBuilder()
- .setName(new QualityMatcherName("qm_q1_any"))
- .setMatcherQuality(ImmutableList.of(new MatcherQualityBuilder(q1)
- .build()))
+ QualityMatcher qm_q1_any = new QualityMatcherBuilder().setName(new QualityMatcherName("qm_q1_any"))
+ .setMatcherQuality(ImmutableList.of(new MatcherQualityBuilder(q1).build()))
.setMatchType(MatchType.Any)
.build();
- QualityMatcher qm_q2q3_any = new QualityMatcherBuilder()
- .setName(new QualityMatcherName("qm_q2q3_any"))
- .setMatcherQuality(ImmutableList.of(new MatcherQualityBuilder(q2)
- .build(),
- new MatcherQualityBuilder(q3)
- .build()))
+ QualityMatcher qm_q2q3_any = new QualityMatcherBuilder().setName(new QualityMatcherName("qm_q2q3_any"))
+ .setMatcherQuality(
+ ImmutableList.of(new MatcherQualityBuilder(q2).build(), new MatcherQualityBuilder(q3).build()))
.setMatchType(MatchType.Any)
.build();
- QualityMatcher qm_q2tq2 = new QualityMatcherBuilder()
- .setName(new QualityMatcherName("qm_q2tq2"))
- .setMatcherQuality(ImmutableList.of(new MatcherQualityBuilder(q2)
- .setTargetNamespace(q2TargetName)
- .build()))
- .setMatchType(MatchType.Any)
- .build();
- QualityMatcher qm_q2q3_plus = new QualityMatcherBuilder()
- .setName(new QualityMatcherName("qm_q2q3_any"))
- .setMatcherQuality(ImmutableList.of(new MatcherQualityBuilder(q3)
- .setTargetNamespace(q2TargetName)
- .build(),
- new MatcherQualityBuilder(q2Exclude)
- .build()))
- .setMatchType(MatchType.All)
- .build();
- QualityMatcher qm_q1_plus = new QualityMatcherBuilder()
- .setName(new QualityMatcherName("qm_q1_any"))
- .build();
+ QualityMatcher qm_q2tq2 =
+ new QualityMatcherBuilder().setName(new QualityMatcherName("qm_q2tq2"))
+ .setMatcherQuality(
+ ImmutableList.of(new MatcherQualityBuilder(q2).setTargetNamespace(q2TargetName).build()))
+ .setMatchType(MatchType.Any)
+ .build();
+ QualityMatcher qm_q2q3_plus =
+ new QualityMatcherBuilder().setName(new QualityMatcherName("qm_q2q3_any"))
+ .setMatcherQuality(
+ ImmutableList.of(new MatcherQualityBuilder(q3).setTargetNamespace(q2TargetName).build(),
+ new MatcherQualityBuilder(q2Exclude).build()))
+ .setMatchType(MatchType.All)
+ .build();
+ QualityMatcher qm_q1_plus = new QualityMatcherBuilder().setName(new QualityMatcherName("qm_q1_any")).build();
SelectorName ctsName1 = new SelectorName("cts1");
- ConsumerTargetSelector cts1 = new ConsumerTargetSelectorBuilder()
- .setName(ctsName1)
+ ConsumerTargetSelector cts1 = new ConsumerTargetSelectorBuilder().setName(ctsName1)
.setQualityMatcher(ImmutableList.of(qm_q1_all, qm_q1_any))
.setRequirement(ImmutableList.of(r2))
.build();
SelectorName ctsName2 = new SelectorName("cts2");
- ConsumerTargetSelector cts2 = new ConsumerTargetSelectorBuilder()
- .setName(ctsName2)
+ ConsumerTargetSelector cts2 = new ConsumerTargetSelectorBuilder().setName(ctsName2)
.setQualityMatcher(ImmutableList.of(qm_q2q3_any))
.setRequirement(ImmutableList.of(r1exclude, r3))
.build();
- ConsumerTargetSelector cts1_plus = new ConsumerTargetSelectorBuilder()
- .setName(ctsName1)
- .setQualityMatcher(ImmutableList.of(qm_q1_plus,
- qm_q2q3_any,
- qm_q1_plus))
+ ConsumerTargetSelector cts1_plus = new ConsumerTargetSelectorBuilder().setName(ctsName1)
+ .setQualityMatcher(ImmutableList.of(qm_q1_plus, qm_q2q3_any, qm_q1_plus))
.setRequirement(ImmutableList.of(r3))
.build();
- ConsumerTargetSelector cts2_plus = new ConsumerTargetSelectorBuilder()
- .setName(ctsName2)
- .setQualityMatcher(ImmutableList.of(qm_q2tq2,
- qm_q2q3_plus))
+ ConsumerTargetSelector cts2_plus = new ConsumerTargetSelectorBuilder().setName(ctsName2)
+ .setQualityMatcher(ImmutableList.of(qm_q2tq2, qm_q2q3_plus))
.setRequirement(ImmutableList.of(r3))
.build();
SelectorName ptsName1 = new SelectorName("pts1");
- ProviderTargetSelector pts1 = new ProviderTargetSelectorBuilder()
- .setName(ptsName1)
+ ProviderTargetSelector pts1 = new ProviderTargetSelectorBuilder().setName(ptsName1)
.setQualityMatcher(ImmutableList.of(qm_q1_all, qm_q1_any))
.setCapability(ImmutableList.of(c2))
.build();
SelectorName ptsName2 = new SelectorName("pts2");
- ProviderTargetSelector pts2 = new ProviderTargetSelectorBuilder()
- .setName(ptsName2)
+ ProviderTargetSelector pts2 = new ProviderTargetSelectorBuilder().setName(ptsName2)
.setQualityMatcher(ImmutableList.of(qm_q2q3_any))
.setCapability(ImmutableList.of(c1exclude, c3))
.build();
- ProviderTargetSelector pts1_plus = new ProviderTargetSelectorBuilder()
- .setName(ptsName1)
- .setQualityMatcher(ImmutableList.of(qm_q1_plus,
- qm_q2q3_any,
- qm_q1_plus))
+ ProviderTargetSelector pts1_plus = new ProviderTargetSelectorBuilder().setName(ptsName1)
+ .setQualityMatcher(ImmutableList.of(qm_q1_plus, qm_q2q3_any, qm_q1_plus))
.setCapability(ImmutableList.of(c3))
.build();
- ProviderTargetSelector pts2_plus = new ProviderTargetSelectorBuilder()
- .setName(ptsName2)
- .setQualityMatcher(ImmutableList.of(qm_q2tq2,
- qm_q2q3_plus))
+ ProviderTargetSelector pts2_plus = new ProviderTargetSelectorBuilder().setName(ptsName2)
+ .setQualityMatcher(ImmutableList.of(qm_q2tq2, qm_q2q3_plus))
.setCapability(ImmutableList.of(c3))
.build();
- EndpointGroupId egId1 =
- new EndpointGroupId("c0e5edfb-02d2-412b-8757-a77b3daeb5d4");
- EndpointGroup eg1 = new EndpointGroupBuilder()
- .setId(egId1)
+ EndpointGroupId egId1 = new EndpointGroupId("c0e5edfb-02d2-412b-8757-a77b3daeb5d4");
+ EndpointGroup eg1 = new EndpointGroupBuilder().setId(egId1)
.setRequirement(ImmutableList.of(r1))
.setCapability(ImmutableList.of(c1))
.setConsumerTargetSelector(ImmutableList.of(cts1, cts2))
.setProviderTargetSelector(ImmutableList.of(pts1, pts2))
.setProviderNamedSelector(ImmutableList.of(pns1))
.build();
- EndpointGroupId egId2 =
- new EndpointGroupId("60483327-ad76-43dd-b3bf-54ffb73ef4b8");
- EndpointGroup eg2 = new EndpointGroupBuilder()
- .setId(egId2)
+ EndpointGroupId egId2 = new EndpointGroupId("60483327-ad76-43dd-b3bf-54ffb73ef4b8");
+ EndpointGroup eg2 = new EndpointGroupBuilder().setId(egId2)
.setParent(egId1)
.setConsumerTargetSelector(ImmutableList.of(cts1_plus, cts2_plus))
.setConsumerNamedSelector(ImmutableList.of(cns1_plus))
.setProviderNamedSelector(ImmutableList.of(pns1_plus))
.build();
- EndpointGroupId egloop2Id =
- new EndpointGroupId("cb5be574-9836-4053-8ec4-4b4a43331d65");
+ EndpointGroupId egloop2Id = new EndpointGroupId("cb5be574-9836-4053-8ec4-4b4a43331d65");
EndpointGroup egloop1 = new EndpointGroupBuilder()
.setId(new EndpointGroupId("a33fdd4d-f58b-4741-a69f-08aecab9af2e"))
.setParent(egloop2Id)
.setConsumerTargetSelector(ImmutableList.of(cts1))
.setProviderTargetSelector(ImmutableList.of(pts1))
.build();
- EndpointGroup egloop2 = new EndpointGroupBuilder()
- .setId(egloop2Id)
- .setParent(egloop1.getId())
- .build();
- EndpointGroupId egselfloopid =
- new EndpointGroupId("996ad104-f852-4d77-96cf-cddde5cebb84");
- EndpointGroup egselfloop = new EndpointGroupBuilder()
- .setId(egselfloopid)
- .setParent(egselfloopid)
- .build();
- EndpointGroup egorphan = new EndpointGroupBuilder()
- .setId(new EndpointGroupId("feafeac9-ce1a-4b19-8455-8fcc9a4ff013"))
- .setParent(new EndpointGroupId("aa9dfcf1-610c-42f9-8c3a-f67b43196821"))
- .build();
+ EndpointGroup egloop2 = new EndpointGroupBuilder().setId(egloop2Id).setParent(egloop1.getId()).build();
+ EndpointGroupId egselfloopid = new EndpointGroupId("996ad104-f852-4d77-96cf-cddde5cebb84");
+ EndpointGroup egselfloop = new EndpointGroupBuilder().setId(egselfloopid).setParent(egselfloopid).build();
+ EndpointGroup egorphan =
+ new EndpointGroupBuilder().setId(new EndpointGroupId("feafeac9-ce1a-4b19-8455-8fcc9a4ff013"))
+ .setParent(new EndpointGroupId("aa9dfcf1-610c-42f9-8c3a-f67b43196821"))
+ .build();
// *******
// Tenants
// Other test state
// ****************
- public boolean containsQuality(List<? extends QualityBase> qualities,
- QualityBase quality) {
+ public boolean containsQuality(List<? extends QualityBase> qualities, QualityBase quality) {
for (QualityBase q : qualities) {
if (q.getName().equals(quality.getName()))
return true;
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
Contract c1 = TenantUtils.findContract(tenant, contractId1);
- // target with a quality directly in the target and one in
+ // target with a quality directly in the target and one in
// the containing contract
Target result = TenantUtils.findTarget(c1, q2TargetName);
+
+ assertNotNull(result);
assertEquals(q2TargetName, result.getName());
List<Quality> qualities = result.getQuality();
- assertTrue(q1.getName() + " found in q2target",
- containsQuality(qualities, q1));
- assertTrue(q2.getName() + " found in q2target",
- containsQuality(qualities, q2));
+ assertTrue(containsQuality(qualities, q1));
+ assertTrue(containsQuality(qualities, q2));
// target with a quality directly in the target with explicit "include"
result = TenantUtils.findTarget(c1, q1IncludeTargetName);
+ assertNotNull(result);
qualities = result.getQuality();
- assertTrue(q1.getName() + " found in q1IncludeTargetName",
- containsQuality(qualities, q1));
+ assertTrue(containsQuality(qualities, q1));
// target with a quality from the containing contract but overridden
// in the target
result = TenantUtils.findTarget(c1, q1ExcludeTargetName);
+ assertNotNull(result);
qualities = result.getQuality();
- assertFalse(q1.getName() + " found in q1ExcludeTargetName",
- containsQuality(qualities, q1));
- assertTrue(q2.getName() + " found in q1ExcludeTargetName",
- containsQuality(qualities, q2));
+ assertFalse(containsQuality(qualities, q1));
+ assertTrue(containsQuality(qualities, q2));
}
@Test
// hits the q2PlusTarget which should include everything in q2Target
// plus q3
Target result = TenantUtils.findTarget(c2, q2TargetName);
+ assertNotNull(result);
List<Quality> qualities = result.getQuality();
- assertTrue(q1.getName() + " found in q2target",
- containsQuality(qualities, q1));
- assertTrue(q2.getName() + " found in q2target",
- containsQuality(qualities, q2));
- assertTrue(q3.getName() + " found in q2target",
- containsQuality(qualities, q3));
+ assertTrue(containsQuality(qualities, q1));
+ assertTrue(containsQuality(qualities, q2));
+ assertTrue(containsQuality(qualities, q3));
// Simple case of inheriting the behavior from the base but not messing
// it up
result = TenantUtils.findTarget(c2, q1IncludeTargetName);
+ assertNotNull(result);
qualities = result.getQuality();
- assertTrue(q1.getName() + " found in q1IncludeTargetName",
- containsQuality(qualities, q1));
- assertFalse(q2.getName() + " found in q1IncludeTargetName",
- containsQuality(qualities, q2));
- assertFalse(q3.getName() + " found in q1IncludeTargetName",
- containsQuality(qualities, q3));
+ assertTrue(containsQuality(qualities, q1));
+ assertFalse(containsQuality(qualities, q2));
+ assertFalse(containsQuality(qualities, q3));
// Inherit a target from the base that isn't found in the child at all
result = TenantUtils.findTarget(c2, q1ExcludeTargetName);
+ assertNotNull(result);
qualities = result.getQuality();
- assertFalse(q1.getName() + " found in q1ExcludeTargetName",
- containsQuality(qualities, q1));
- assertTrue(q2.getName() + " found in q1ExcludeTargetName",
- containsQuality(qualities, q2));
- assertFalse(q3.getName() + " found in q1ExcludeTargetName",
- containsQuality(qualities, q3));
+ assertFalse(containsQuality(qualities, q1));
+ assertTrue(containsQuality(qualities, q2));
+ assertFalse(containsQuality(qualities, q3));
}
- private boolean containsRequirement(List<? extends RequirementBase> requirements,
- RequirementBase requirement) {
+ private boolean containsRequirement(List<? extends RequirementBase> requirements, RequirementBase requirement) {
for (RequirementBase r : requirements) {
if (r.getName().equals(requirement.getName()))
return true;
return false;
}
- private boolean containsCapability(List<? extends CapabilityBase> capabilities,
- CapabilityBase capability) {
+ private boolean containsCapability(List<? extends CapabilityBase> capabilities, CapabilityBase capability) {
for (CapabilityBase r : capabilities) {
if (r.getName().equals(capability.getName()))
return true;
return false;
}
- private boolean containsCondition(List<? extends Condition> conditions,
- Condition condition) {
+ private boolean containsCondition(List<? extends Condition> conditions, Condition condition) {
for (Condition r : conditions) {
if (r.getName().equals(condition.getName()))
return true;
EndpointGroup egResult1 = TenantUtils.findEndpointGroup(tenant, egId1);
// should get r1 from eg1 and r2 from target selector
- ConsumerTargetSelector result =
- TenantUtils.findCts(egResult1, ctsName1);
+ ConsumerTargetSelector result = TenantUtils.findCts(egResult1, ctsName1);
+ assertNotNull(result);
assertEquals(ctsName1, result.getName());
List<Requirement> requirements = result.getRequirement();
- assertTrue(r1.getName() + " found in " + requirements,
- containsRequirement(requirements, r1));
- assertTrue(r2.getName() + " found in " + requirements,
- containsRequirement(requirements, r2));
+ assertTrue(containsRequirement(requirements, r1));
+ assertTrue(containsRequirement(requirements, r2));
List<QualityMatcher> matchers = result.getQualityMatcher();
assertEquals(2, matchers.size());
for (QualityMatcher m : matchers) {
if (m.getName().equals(new QualityMatcherName("qm_q1_all"))) {
assertTrue(containsQuality(m.getMatcherQuality(), q1));
- assertEquals(MatchType.All, m.getMatchType());
+ assertEquals(MatchType.All, m.getMatchType());
} else {
assertTrue(containsQuality(m.getMatcherQuality(), q1));
assertEquals(MatchType.Any, m.getMatchType());
// should get r1 from eg1 but excluded in target selector
// r3 comes from target selector
result = TenantUtils.findCts(egResult1, ctsName2);
+ assertNotNull(result);
assertEquals(ctsName2, result.getName());
requirements = result.getRequirement();
- assertFalse(r1.getName() + " found in " + requirements,
- containsRequirement(requirements, r1));
- assertFalse(r2.getName() + " found in " + requirements,
- containsRequirement(requirements, r2));
- assertTrue(r3.getName() + " found in " + requirements,
- containsRequirement(requirements, r3));
+ assertFalse(containsRequirement(requirements, r1));
+ assertFalse(containsRequirement(requirements, r2));
+ assertTrue(containsRequirement(requirements, r3));
matchers = result.getQualityMatcher();
assertEquals(1, matchers.size());
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
EndpointGroup egResult2 = TenantUtils.findEndpointGroup(tenant, egId2);
- ConsumerTargetSelector result =
- TenantUtils.findCts(egResult2, ctsName1);
+ ConsumerTargetSelector result = TenantUtils.findCts(egResult2, ctsName1);
+ assertNotNull(result);
List<Requirement> requirements = result.getRequirement();
- assertTrue(r1.getName() + " found in " + requirements,
- containsRequirement(requirements, r1));
- assertTrue(r3.getName() + " found in " + requirements,
- containsRequirement(requirements, r3));
+ assertTrue(containsRequirement(requirements, r1));
+ assertTrue(containsRequirement(requirements, r3));
- // should have three matchers,
+ // should have three matchers,
// (1) qm_q1_all inherited from endpoint group 1
- // (2) qm_q1_any inherited from endpoint group 1, but overridden in
- // endpoint group 2 with no new semantics
+ // (2) qm_q1_any inherited from endpoint group 1, but overridden in
+ // endpoint group 2 with no new semantics
// (3) qm_q2q3_any defined in endpoint group 2
List<QualityMatcher> matchers = result.getQualityMatcher();
assertEquals(3, matchers.size());
}
result = TenantUtils.findCts(egResult2, ctsName2);
+ assertNotNull(result);
assertEquals(ctsName2, result.getName());
requirements = result.getRequirement();
// should get r1 from eg1 but excluded in target selector
// r3 comes from target selector
- assertFalse(r1.getName() + " found in " + requirements,
- containsRequirement(requirements, r1));
- assertFalse(r2.getName() + " found in " + requirements,
- containsRequirement(requirements, r2));
- assertTrue(r3.getName() + " found in " + requirements,
- containsRequirement(requirements, r3));
-
- // Should get 2 matchers:
- // (1) qm_q2q2_any inherited from eg1, except that q2 is excluded
- // by qm_q2q3_plus and q3 has a target namespace added
+ assertFalse(containsRequirement(requirements, r1));
+ assertFalse(containsRequirement(requirements, r2));
+ assertTrue(containsRequirement(requirements, r3));
+
+ // Should get 2 matchers:
+ // (1) qm_q2q2_any inherited from eg1, except that q2 is excluded
+ // by qm_q2q3_plus and q3 has a target namespace added
// (2) qm_q2tq2_any newly-defined with a target namespace
matchers = result.getQualityMatcher();
assertEquals(2, matchers.size());
assertTrue(containsQuality(m.getMatcherQuality(), q2));
assertEquals(MatchType.Any, m.getMatchType());
assertEquals(1, m.getMatcherQuality().size());
- assertEquals(q2TargetName,
- m.getMatcherQuality().get(0).getTargetNamespace());
+ assertEquals(q2TargetName, m.getMatcherQuality().get(0).getTargetNamespace());
}
}
}
EndpointGroup egResult1 = TenantUtils.findEndpointGroup(tenant, egId1);
// should get r1 from eg1 and r2 from selector
- ConsumerNamedSelector result =
- TenantUtils.findCns(egResult1, cnsName1);
+ ConsumerNamedSelector result = TenantUtils.findCns(egResult1, cnsName1);
+ assertNotNull(result);
assertEquals(cnsName1, result.getName());
List<Requirement> requirements = result.getRequirement();
assertEquals(2, requirements.size());
- assertTrue(r1.getName() + " found in " + requirements,
- containsRequirement(requirements, r1));
- assertTrue(r2.getName() + " found in " + requirements,
- containsRequirement(requirements, r2));
-
+ assertTrue(containsRequirement(requirements, r1));
+ assertTrue(containsRequirement(requirements, r2));
assertEquals(1, result.getContract().size());
- HashSet<ContractId> cids = new HashSet<>();
- cids.addAll(result.getContract());
- assertEquals(ImmutableSet.of(contractId1), cids);
+ assertTrue(result.getContract().contains(contractId1));
}
@Test
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
EndpointGroup egResult2 = TenantUtils.findEndpointGroup(tenant, egId2);
- // should get r1 from eg1 and r2 from eg1 selector,
+ // should get r1 from eg1 and r2 from eg1 selector,
// and r3 from eg2 selector
- ConsumerNamedSelector result =
- TenantUtils.findCns(egResult2, cnsName1);
+ ConsumerNamedSelector result = TenantUtils.findCns(egResult2, cnsName1);
+ assertNotNull(result);
assertEquals(cnsName1, result.getName());
List<Requirement> requirements = result.getRequirement();
assertEquals(3, requirements.size());
- assertTrue(r1.getName() + " found in " + requirements,
- containsRequirement(requirements, r1));
- assertTrue(r2.getName() + " found in " + requirements,
- containsRequirement(requirements, r2));
- assertTrue(r3.getName() + " found in " + requirements,
- containsRequirement(requirements, r3));
+ assertTrue(containsRequirement(requirements, r1));
+ assertTrue(containsRequirement(requirements, r2));
+ assertTrue(containsRequirement(requirements, r3));
assertEquals(2, result.getContract().size());
- HashSet<ContractId> cids = new HashSet<>();
- cids.addAll(result.getContract());
- assertEquals(ImmutableSet.of(contractId1, contractId2), cids);
+ assertTrue(result.getContract().containsAll(ImmutableSet.of(contractId1, contractId2)));
}
@Test
EndpointGroup egResult1 = TenantUtils.findEndpointGroup(tenant, egId1);
// should get c1 from eg1 and c2 from target selector
- ProviderTargetSelector result =
- TenantUtils.findPts(egResult1, ptsName1);
+ ProviderTargetSelector result = TenantUtils.findPts(egResult1, ptsName1);
+ assertNotNull(result);
assertEquals(ptsName1, result.getName());
List<Capability> capabilities = result.getCapability();
- assertTrue(c1.getName() + " found in " + capabilities,
- containsCapability(capabilities, c1));
- assertTrue(c2.getName() + " found in " + capabilities,
- containsCapability(capabilities, c2));
+ assertTrue(containsCapability(capabilities, c1));
+ assertTrue(containsCapability(capabilities, c2));
List<QualityMatcher> matchers = result.getQualityMatcher();
assertEquals(2, matchers.size());
for (QualityMatcher m : matchers) {
if (m.getName().equals(new QualityMatcherName("qm_q1_all"))) {
assertTrue(containsQuality(m.getMatcherQuality(), q1));
- assertEquals(MatchType.All, m.getMatchType());
+ assertEquals(MatchType.All, m.getMatchType());
} else {
assertTrue(containsQuality(m.getMatcherQuality(), q1));
assertEquals(MatchType.Any, m.getMatchType());
// should get c1 from eg1 but excluded in target selector
// c3 comes from target selector
result = TenantUtils.findPts(egResult1, ptsName2);
+ assertNotNull(result);
assertEquals(ptsName2, result.getName());
capabilities = result.getCapability();
- assertFalse(c1.getName() + " found in " + capabilities,
- containsCapability(capabilities, c1));
- assertFalse(c2.getName() + " found in " + capabilities,
- containsCapability(capabilities, c2));
- assertTrue(c3.getName() + " found in " + capabilities,
- containsCapability(capabilities, c3));
+ assertFalse(containsCapability(capabilities, c1));
+ assertFalse(containsCapability(capabilities, c2));
+ assertTrue(containsCapability(capabilities, c3));
matchers = result.getQualityMatcher();
assertEquals(1, matchers.size());
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
EndpointGroup egResult2 = TenantUtils.findEndpointGroup(tenant, egId2);
- ProviderTargetSelector result =
- TenantUtils.findPts(egResult2, ptsName1);
+ ProviderTargetSelector result = TenantUtils.findPts(egResult2, ptsName1);
+ assertNotNull(result);
List<Capability> capabilities = result.getCapability();
- assertTrue(c1.getName() + " found in " + capabilities,
- containsCapability(capabilities, c1));
- assertTrue(c3.getName() + " found in " + capabilities,
- containsCapability(capabilities, c3));
+ assertTrue(containsCapability(capabilities, c1));
+ assertTrue(containsCapability(capabilities, c3));
- // should have three matchers,
+ // should have three matchers,
// (1) qm_q1_all inherited from endpoint group 1
- // (2) qm_q1_any inherited from endpoint group 1, but overridden in
- // endpoint group 2 with no new semantics
+ // (2) qm_q1_any inherited from endpoint group 1, but overridden in
+ // endpoint group 2 with no new semantics
// (3) qm_q2q3_any defined in endpoint group 2
List<QualityMatcher> matchers = result.getQualityMatcher();
assertEquals(3, matchers.size());
}
result = TenantUtils.findPts(egResult2, ptsName2);
+ assertNotNull(result);
assertEquals(ptsName2, result.getName());
capabilities = result.getCapability();
// should get c1 from eg1 but excluded in target selector
// c3 comes from target selector
- assertFalse(c1.getName() + " found in " + capabilities,
- containsCapability(capabilities, c1));
- assertFalse(c2.getName() + " found in " + capabilities,
- containsCapability(capabilities, c2));
- assertTrue(c3.getName() + " found in " + capabilities,
- containsCapability(capabilities, c3));
-
- // Should get 2 matchers:
- // (1) qm_q2q2_any inherited from eg1, except that q2 is excluded
- // by qm_q2q3_plus and q3 has a target namespace added
+ assertFalse(containsCapability(capabilities, c1));
+ assertFalse(containsCapability(capabilities, c2));
+ assertTrue(containsCapability(capabilities, c3));
+
+ // Should get 2 matchers:
+ // (1) qm_q2q2_any inherited from eg1, except that q2 is excluded
+ // by qm_q2q3_plus and q3 has a target namespace added
// (2) qm_q2tq2_any newly-defined with a target namespace
matchers = result.getQualityMatcher();
assertEquals(2, matchers.size());
assertTrue(containsQuality(m.getMatcherQuality(), q2));
assertEquals(MatchType.Any, m.getMatchType());
assertEquals(1, m.getMatcherQuality().size());
- assertEquals(q2TargetName,
- m.getMatcherQuality().get(0).getTargetNamespace());
+ assertEquals(q2TargetName, m.getMatcherQuality().get(0).getTargetNamespace());
}
}
}
public void testProviderNamedSelectorSimple() throws Exception {
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
EndpointGroup egResult1 = TenantUtils.findEndpointGroup(tenant, egId1);
-
+
// should get c1 from eg1 and c2 from selector
- ProviderNamedSelector result =
- TenantUtils.findPns(egResult1, cnsName1);
+ ProviderNamedSelector result = TenantUtils.findPns(egResult1, cnsName1);
+ assertNotNull(result);
assertEquals(cnsName1, result.getName());
List<Capability> capabilities = result.getCapability();
assertEquals(2, capabilities.size());
- assertTrue(c1.getName() + " found in " + capabilities,
- containsCapability(capabilities, c1));
- assertTrue(c2.getName() + " found in " + capabilities,
- containsCapability(capabilities, c2));
+ assertTrue(containsCapability(capabilities, c1));
+ assertTrue(containsCapability(capabilities, c2));
assertEquals(1, result.getContract().size());
- HashSet<ContractId> cids = new HashSet<>();
- cids.addAll(result.getContract());
- assertEquals(ImmutableSet.of(contractId1), cids);
+ assertTrue(result.getContract().contains(contractId1));
}
@Test
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
EndpointGroup egResult2 = TenantUtils.findEndpointGroup(tenant, egId2);
- // should get c1 from eg1 and c2 from eg1 selector,
+ // should get c1 from eg1 and c2 from eg1 selector,
// and c3 from eg2 selector
- ProviderNamedSelector result =
- TenantUtils.findPns(egResult2, cnsName1);
+ ProviderNamedSelector result = TenantUtils.findPns(egResult2, cnsName1);
+ assertNotNull(result);
assertEquals(cnsName1, result.getName());
List<Capability> capabilities = result.getCapability();
assertEquals(3, capabilities.size());
- assertTrue(c1.getName() + " found in " + capabilities,
- containsCapability(capabilities, c1));
- assertTrue(c2.getName() + " found in " + capabilities,
- containsCapability(capabilities, c2));
- assertTrue(c3.getName() + " found in " + capabilities,
- containsCapability(capabilities, c3));
+ assertTrue(containsCapability(capabilities, c1));
+ assertTrue(containsCapability(capabilities, c2));
+ assertTrue(containsCapability(capabilities, c3));
assertEquals(2, result.getContract().size());
- HashSet<ContractId> cids = new HashSet<>();
- cids.addAll(result.getContract());
- assertEquals(ImmutableSet.of(contractId1, contractId2), cids);
+ assertTrue(result.getContract().containsAll(ImmutableSet.of(contractId1, contractId2)));
}
@Test
public void testClauseSimple() throws Exception {
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
Contract cresult1 = TenantUtils.findContract(tenant, contractId1);
-
+
Clause result = TenantUtils.findClause(cresult1, clauseName1);
+ assertNotNull(result);
assertEquals(clauseName1, result.getName());
// subject refs: subject1 from clause1
assertEquals(1, result.getSubjectRefs().size());
- assertEquals(ImmutableSet.of(subject1),
- ImmutableSet.copyOf(result.getSubjectRefs()));
+ assertEquals(ImmutableSet.of(subject1), ImmutableSet.copyOf(result.getSubjectRefs()));
assertNotNull(result.getProviderMatchers());
- List<ConditionMatcher> cm =
- result.getProviderMatchers().getConditionMatcher();
+ List<ConditionMatcher> cm = result.getProviderMatchers().getConditionMatcher();
assertEquals(1, cm.size());
assertEquals(1, cm.get(0).getCondition().size());
assertTrue(containsCondition(cm.get(0).getCondition(), cond1));
-
- List<CapabilityMatcher> capm =
- ((GroupCapabilityConstraintCase)result.getProviderMatchers().getGroupIdentificationConstraints()).getCapabilityMatcher();
+ List<CapabilityMatcher> capm =
+ ((GroupCapabilityConstraintCase) result.getProviderMatchers().getGroupIdentificationConstraints())
+ .getCapabilityMatcher();
assertEquals(1, capm.size());
assertEquals(1, capm.get(0).getMatcherCapability().size());
assertTrue(containsCapability(capm.get(0).getMatcherCapability(), c1));
-
+
assertNotNull(result.getConsumerMatchers());
cm = result.getConsumerMatchers().getConditionMatcher();
assertEquals(1, cm.size());
assertEquals(1, cm.get(0).getCondition().size());
assertTrue(containsCondition(cm.get(0).getCondition(), cond2));
- List<RequirementMatcher> pm =
- ((GroupRequirementConstraintCase)result.getConsumerMatchers().getGroupIdentificationConstraints()).getRequirementMatcher();
+ List<RequirementMatcher> pm =
+ ((GroupRequirementConstraintCase) result.getConsumerMatchers().getGroupIdentificationConstraints())
+ .getRequirementMatcher();
assertEquals(1, pm.size());
assertEquals(1, pm.get(0).getMatcherRequirement().size());
assertTrue(containsRequirement(pm.get(0).getMatcherRequirement(), r1));
-
+
}
@Test
Contract cresult2 = TenantUtils.findContract(tenant, contractId2);
Clause result = TenantUtils.findClause(cresult2, clauseName1);
+ assertNotNull(result);
assertEquals(clauseName1, result.getName());
-
+
// subject refs: subject1 from clause1, subject2 from clause2
assertEquals(2, result.getSubjectRefs().size());
- assertEquals(ImmutableSet.of(subject1, subject2),
- ImmutableSet.copyOf(result.getSubjectRefs()));
+ assertEquals(ImmutableSet.of(subject1, subject2), ImmutableSet.copyOf(result.getSubjectRefs()));
assertNotNull(result.getProviderMatchers());
- List<ConditionMatcher> cm =
- result.getProviderMatchers().getConditionMatcher();
+ List<ConditionMatcher> cm = result.getProviderMatchers().getConditionMatcher();
assertEquals(1, cm.size());
assertEquals(1, cm.get(0).getCondition().size());
assertTrue(containsCondition(cm.get(0).getCondition(), cond1));
- List<CapabilityMatcher> capm =
- ((GroupCapabilityConstraintCase)result.getProviderMatchers().getGroupIdentificationConstraints()).getCapabilityMatcher();
+ List<CapabilityMatcher> capm =
+ ((GroupCapabilityConstraintCase) result.getProviderMatchers().getGroupIdentificationConstraints())
+ .getCapabilityMatcher();
assertEquals(1, capm.size());
assertEquals(1, capm.get(0).getMatcherCapability().size());
assertTrue(containsCapability(capm.get(0).getMatcherCapability(), c1));
assertEquals(MatchType.All, cm.get(0).getMatchType());
assertEquals(0, cm.get(0).getCondition().size());
- List<RequirementMatcher> pm =
- ((GroupRequirementConstraintCase)result.getConsumerMatchers().getGroupIdentificationConstraints()).getRequirementMatcher();
+ List<RequirementMatcher> pm =
+ ((GroupRequirementConstraintCase) result.getConsumerMatchers().getGroupIdentificationConstraints())
+ .getRequirementMatcher();
assertEquals(1, pm.size());
assertEquals(2, pm.get(0).getMatcherRequirement().size());
assertTrue(containsRequirement(pm.get(0).getMatcherRequirement(), r1));
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
Contract result = TenantUtils.findContract(tenant, contractId1);
+ assertNotNull(result);
List<Subject> subjects = result.getSubject();
assertEquals(1, subjects.size());
-
+
assertEquals(s1.getName(), subjects.get(0).getName());
List<Rule> rules = subjects.get(0).getRule();
assertEquals(2, rules.size());
Tenant tenant = InheritanceUtils.resolveTenant(tenant1);
Contract result = TenantUtils.findContract(tenant, contractId2);
+ assertNotNull(result);
List<Subject> subjects = result.getSubject();
assertEquals(2, subjects.size());
- for (Subject s: subjects) {
+ for (Subject s : subjects) {
if (s1.getName().equals(s.getName())) {
assertEquals(Integer.valueOf(4), s.getOrder());
List<Rule> rules = s.getRule();
@Test
public void testMalformedPolicy() throws Exception {
- Tenant tenant =
- InheritanceUtils.resolveTenant(malformed);
- Contract c = TenantUtils.findContract(tenant, cloop2Id);
- assertEquals(1, c.getClause().size());
- Clause clause = c.getClause().get(0);
+ Tenant tenant = InheritanceUtils.resolveTenant(malformed);
+ Contract contract = TenantUtils.findContract(tenant, cloop2Id);
+ assertNotNull(contract);
+ assertEquals(1, contract.getClause().size());
+ Clause clause = contract.getClause().get(0);
assertEquals(1, clause.getConsumerMatchers().getConditionMatcher().size());
- assertEquals(1, ((GroupRequirementConstraintCase)clause.getConsumerMatchers().getGroupIdentificationConstraints()).getRequirementMatcher().size());
+ assertEquals(1,
+ ((GroupRequirementConstraintCase) clause.getConsumerMatchers().getGroupIdentificationConstraints())
+ .getRequirementMatcher().size());
assertEquals(1, clause.getProviderMatchers().getConditionMatcher().size());
- assertEquals(1, ((GroupCapabilityConstraintCase)clause.getProviderMatchers().getGroupIdentificationConstraints()).getCapabilityMatcher().size());
- assertEquals(2, c.getSubject().size());
+ assertEquals(1,
+ ((GroupCapabilityConstraintCase) clause.getProviderMatchers().getGroupIdentificationConstraints())
+ .getCapabilityMatcher().size());
+ assertEquals(2, contract.getSubject().size());
EndpointGroup eg = TenantUtils.findEndpointGroup(tenant, egloop2Id);
+ assertNotNull(eg);
assertEquals(1, eg.getConsumerNamedSelector().size());
assertEquals(1, eg.getConsumerTargetSelector().size());
assertEquals(1, eg.getProviderNamedSelector().size());
/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
private ConditionSet conditionSet;
@Before
- public void Initialisation() {
+ public void init() {
consEgKey = mock(EgKey.class);
provEgKey = mock(EgKey.class);
policy = mock(Policy.class);
policyMap.put(consEgKey, provEgKey, policy);
conditionSet = mock(ConditionSet.class);
- conditionSets = new HashSet<ConditionSet>(Arrays.asList(conditionSet));
- egConditions = new HashMap<EgKey, Set<ConditionSet>>();
+ conditionSets = new HashSet<>(Collections.singletonList(conditionSet));
+ egConditions = new HashMap<>();
condEgKey = mock(EgKey.class);
egConditions.put(condEgKey, conditionSets);
}
@Test
- public void constructorTest() {
+ public void testConstructor() {
Assert.assertEquals(policyMap, policyInfo.getPolicyMap());
Assert.assertEquals(policy, policyInfo.getPolicy(consEgKey, provEgKey));
Assert.assertEquals(Policy.EMPTY, policyInfo.getPolicy(provEgKey, consEgKey));
}
@Test
- public void getEgCondGroupTest() {
+ public void testGetEgCondGroup() {
List<ConditionName> conditions = Collections.emptyList();
ConditionGroup conditionGroup;
}
@Test
- public void getPeersTest() {
+ public void testGetPeers() {
Set<EgKey> peers;
peers = policyInfo.getPeers(consEgKey);
Assert.assertTrue(peers.contains(provEgKey));
package org.opendaylight.groupbasedpolicy.resolver;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.Arrays;
+import java.util.Collections;
import java.util.HashSet;
import org.junit.Assert;
import org.junit.Test;
-import org.opendaylight.groupbasedpolicy.dto.EgKey;
import org.opendaylight.groupbasedpolicy.dto.IndexedTenant;
-import org.opendaylight.groupbasedpolicy.dto.Policy;
import org.opendaylight.groupbasedpolicy.util.PolicyResolverUtils;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClauseName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SelectorName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TargetName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.TenantBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.Policy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.PolicyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.Contract;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ContractBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Clause;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.ClauseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Subject;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.SubjectBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Target;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.TargetBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ConsumerNamedSelector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ConsumerNamedSelectorBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ConsumerTargetSelector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ConsumerTargetSelectorBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderNamedSelector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderNamedSelectorBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderTargetSelector;
-
-import com.google.common.collect.Table;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderTargetSelectorBuilder;
public class PolicyResolverUtilsTest {
@Test
- public void resolvePolicyTest() {
- IndexedTenant indexedTenant = mock(IndexedTenant.class);
- HashSet<IndexedTenant> tenants = new HashSet<IndexedTenant>();
- tenants.add(indexedTenant);
- Tenant tenant = mock(Tenant.class);
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.Policy policy =
- mock(org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.Policy.class);
- when(tenant.getPolicy()).thenReturn(policy);
- when(indexedTenant.getTenant()).thenReturn(tenant);
+ public void testResolvePolicy() {
+ Target target = new TargetBuilder().setName(new TargetName("targetName")).build();
+
+ Clause clause = new ClauseBuilder().setName(ClauseName.getDefaultInstance("clauseName")).build();
+ Subject subject = new SubjectBuilder().setName(new SubjectName("subjectName")).build();
+ ContractId contractId = new ContractId("contractId");
+ Contract contract = new ContractBuilder().setId(contractId)
+ .setTarget(Collections.singletonList(target))
+ .setClause(Collections.singletonList(clause))
+ .setSubject(Collections.singletonList(subject))
+ .build();
+ ProviderNamedSelector pns = new ProviderNamedSelectorBuilder().setName(new SelectorName("pnsName"))
+ .setContract(Collections.singletonList(contractId))
+ .build();
+ ConsumerNamedSelector cns = new ConsumerNamedSelectorBuilder().setName(new SelectorName("cnsName"))
+ .setContract(Collections.singletonList(contractId))
+ .build();
+ ProviderTargetSelector pts = new ProviderTargetSelectorBuilder().setName(new SelectorName("ptsName")).build();
+ ConsumerTargetSelector cts = new ConsumerTargetSelectorBuilder().setName(new SelectorName("ctsName")).build();
- EndpointGroup endpointGroup = mock(EndpointGroup.class);
- when(policy.getEndpointGroup()).thenReturn(Arrays.asList(endpointGroup));
- ConsumerNamedSelector cns = mock(ConsumerNamedSelector.class);
- when(endpointGroup.getConsumerNamedSelector()).thenReturn(Arrays.asList(cns));
- ContractId contractId = mock(ContractId.class);
- when(cns.getContract()).thenReturn(Arrays.asList(contractId));
- Contract contract = mock(Contract.class);
- when(policy.getContract()).thenReturn(Arrays.asList(contract));
- when(contract.getId()).thenReturn(contractId);
- TenantId tenantId = mock(TenantId.class);
- when(tenant.getId()).thenReturn(tenantId);
+ EndpointGroup endpointGroup =
+ new EndpointGroupBuilder().setProviderNamedSelector(Collections.singletonList(pns))
+ .setConsumerNamedSelector(Collections.singletonList(cns))
+ .setProviderTargetSelector(Collections.singletonList(pts))
+ .setConsumerTargetSelector(Collections.singletonList(cts))
+ .build();
+ Policy policy = new PolicyBuilder().setEndpointGroup(Collections.singletonList(endpointGroup))
+ .setContract(Collections.singletonList(contract))
+ .build();
+ Tenant tenant = new TenantBuilder().setId(new TenantId("tenantId")).setPolicy(policy).build();
+ IndexedTenant indexedTenant = new IndexedTenant(tenant);
- ProviderNamedSelector pns = mock(ProviderNamedSelector.class);
- when(endpointGroup.getProviderNamedSelector()).thenReturn(Arrays.asList(pns));
- ProviderTargetSelector pts = mock(ProviderTargetSelector.class);
- when(endpointGroup.getProviderTargetSelector()).thenReturn(Arrays.asList(pts));
- Target t = mock(Target.class);
- when(contract.getTarget()).thenReturn(Arrays.asList(t));
- ConsumerTargetSelector cts = mock(ConsumerTargetSelector.class);
- when(endpointGroup.getConsumerTargetSelector()).thenReturn(Arrays.asList(cts));
+ HashSet<IndexedTenant> indexedTenants = new HashSet<>();
+ indexedTenants.add(indexedTenant);
- Table<EgKey, EgKey, Policy> policyTable = PolicyResolverUtils.resolvePolicy(tenants);
- Assert.assertEquals(1, policyTable.size());
+ Assert.assertEquals(1, PolicyResolverUtils.resolvePolicy(indexedTenants).size());
}
}
package org.opendaylight.groupbasedpolicy.resolver;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
-import java.util.Arrays;
+import java.util.Collections;
import java.util.List;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.groupbasedpolicy.dto.RuleGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.TenantBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.Contract;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ContractKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ContractBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.Rule;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.RuleBuilder;
public class RuleGroupTest {
- private Rule rule;
+ private static final int ORDER = 5;
+ private static final int ORDER_LESSER = 3;
+ private static final int ORDER_BIGGER = 8;
+ private static final String SN_VALUE = "sn_value";
+ private static final String SN_OTHER = "sn_other";
+ private static final String SN_COMES_BEFORE = "sn_armadillo";
+ private static final String SN_COMES_AFTER = "sn_zebra";
+ private static final String RULE_NAME = "ruleName";
+ private static final String RULE_OTHER = "ruleOther";
+ private static final String TENANT_ID = "tenantId";
+ private static final String CONTRACT_ID = "contractId";
+
private List<Rule> rules;
private Integer order;
private Tenant contractTenant;
private Contract contract;
- private SubjectName subject;
- private String subjectValue;
+ private SubjectName subjectName;
private RuleGroup ruleGroup;
@Before
- public void initialisation() {
- rule = mock(Rule.class);
- rules = Arrays.asList(rule);
- order = Integer.valueOf(5);
- contractTenant = mock(Tenant.class);
- contract = mock(Contract.class);
- subject = mock(SubjectName.class);
-
- subjectValue = "value";
- when(subject.getValue()).thenReturn(subjectValue);
- ContractId contractId = new ContractId("contract");
- when(contract.getKey()).thenReturn(new ContractKey(contractId));
-
- ruleGroup = new RuleGroup(rules, order, contractTenant, contract, subject);
+ public void init() {
+ Rule rule = new RuleBuilder().setName(new RuleName(RULE_NAME)).build();
+ rules = Collections.singletonList(rule);
+ order = ORDER;
+ contractTenant = new TenantBuilder().setId(new TenantId(TENANT_ID)).build();
+ contract = new ContractBuilder().setId(new ContractId(CONTRACT_ID)).build();
+ subjectName = new SubjectName(SN_VALUE);
+
+ ruleGroup = new RuleGroup(rules, order, contractTenant, contract, subjectName);
}
@Test
- public void constructorTest() {
- Assert.assertNotNull(ruleGroup);
- Assert.assertEquals(rules, ruleGroup.getRules());
- Assert.assertEquals(order, ruleGroup.getOrder());
- Assert.assertEquals(contractTenant, ruleGroup.getContractTenant());
- Assert.assertEquals(contract, ruleGroup.getRelatedContract());
- Assert.assertEquals(subject, ruleGroup.getRelatedSubject());
+ public void testConstructor() {
+ assertNotNull(ruleGroup);
+ assertEquals(rules, ruleGroup.getRules());
+ assertEquals(order, ruleGroup.getOrder());
+ assertEquals(contractTenant, ruleGroup.getContractTenant());
+ assertEquals(contract, ruleGroup.getRelatedContract());
+ assertEquals(subjectName, ruleGroup.getRelatedSubject());
}
@Test
- public void equalsTest() {
- Assert.assertTrue(ruleGroup.equals(ruleGroup));
- Assert.assertFalse(ruleGroup.equals(null));
- Assert.assertFalse(ruleGroup.equals(new Object()));
+ public void testEquals() {
+ assertTrue(ruleGroup.equals(ruleGroup));
+ assertFalse(ruleGroup.equals(null));
+ assertFalse(ruleGroup.equals(new Object()));
RuleGroup other;
- Integer orderOther = Integer.valueOf(3);
- other = new RuleGroup(rules, orderOther, contractTenant, contract, subject);
- Assert.assertFalse(ruleGroup.equals(other));
+ Integer orderOther = 3;
+ other = new RuleGroup(rules, orderOther, contractTenant, contract, subjectName);
+ assertFalse(ruleGroup.equals(other));
- Rule ruleOther = mock(Rule.class);
- List<Rule> rulesOther = Arrays.asList(ruleOther);
- other = new RuleGroup(rulesOther, order, contractTenant, contract, subject);
- Assert.assertFalse(ruleGroup.equals(other));
+ Rule ruleOther = new RuleBuilder().setName(new RuleName(RULE_OTHER)).build();
+ List<Rule> rulesOther = Collections.singletonList(ruleOther);
+ other = new RuleGroup(rulesOther, order, contractTenant, contract, subjectName);
+ assertFalse(ruleGroup.equals(other));
- SubjectName subjectOther = mock(SubjectName.class);
- other = new RuleGroup(rules, order, contractTenant, contract, subjectOther);
- Assert.assertFalse(ruleGroup.equals(other));
+ SubjectName subjectNameOther = new SubjectName(SN_OTHER);
+ other = new RuleGroup(rules, order, contractTenant, contract, subjectNameOther);
+ assertFalse(ruleGroup.equals(other));
- other = new RuleGroup(rules, order, contractTenant, contract, subject);
- Assert.assertTrue(ruleGroup.equals(other));
+ other = new RuleGroup(rules, order, contractTenant, contract, this.subjectName);
+ assertTrue(ruleGroup.equals(other));
- ruleGroup = new RuleGroup(rules, null, contractTenant, contract, subject);
- Assert.assertFalse(ruleGroup.equals(other));
- other = new RuleGroup(rules, null, contractTenant, contract, subject);
- Assert.assertTrue(ruleGroup.equals(other));
+ ruleGroup = new RuleGroup(rules, null, contractTenant, contract, this.subjectName);
+ assertFalse(ruleGroup.equals(other));
+ other = new RuleGroup(rules, null, contractTenant, contract, this.subjectName);
+ assertTrue(ruleGroup.equals(other));
- other = new RuleGroup(rules, order, contractTenant, contract, subject);
+ other = new RuleGroup(rules, order, contractTenant, contract, this.subjectName);
ruleGroup = new RuleGroup(rules, order, contractTenant, contract, null);
- Assert.assertFalse(ruleGroup.equals(other));
+ assertFalse(ruleGroup.equals(other));
other = new RuleGroup(rules, order, contractTenant, contract, null);
- Assert.assertTrue(ruleGroup.equals(other));
+ assertTrue(ruleGroup.equals(other));
}
@Test
- public void compareToTest() {
+ public void testCompareTo() {
RuleGroup other;
- other = new RuleGroup(rules, order, contractTenant, contract, subject);
- Assert.assertEquals(0, ruleGroup.compareTo(other));
+ other = new RuleGroup(rules, order, contractTenant, contract, subjectName);
+ assertEquals(0, ruleGroup.compareTo(other));
Integer orderOther;
- orderOther = Integer.valueOf(3);
- other = new RuleGroup(rules, orderOther, contractTenant, contract, subject);
- Assert.assertEquals(1, ruleGroup.compareTo(other));
+ orderOther = ORDER_LESSER;
+ other = new RuleGroup(rules, orderOther, contractTenant, contract, subjectName);
+ assertEquals(1, ruleGroup.compareTo(other));
- orderOther = Integer.valueOf(8);
- other = new RuleGroup(rules, orderOther, contractTenant, contract, subject);
- Assert.assertEquals(-1, ruleGroup.compareTo(other));
+ orderOther = ORDER_BIGGER;
+ other = new RuleGroup(rules, orderOther, contractTenant, contract, subjectName);
+ assertEquals(-1, ruleGroup.compareTo(other));
- SubjectName subjectOther = mock(SubjectName.class);
+ SubjectName subjectNameComesBefore = new SubjectName(SN_COMES_BEFORE);
+ SubjectName subjectNameComesLater = new SubjectName(SN_COMES_AFTER);
- when(subjectOther.getValue()).thenReturn("valu");
- other = new RuleGroup(rules, order, contractTenant, contract, subjectOther);
- Assert.assertEquals(1, ruleGroup.compareTo(other));
+ other = new RuleGroup(rules, order, contractTenant, contract, subjectNameComesBefore);
+ assertEquals(1, ruleGroup.compareTo(other));
- when(subjectOther.getValue()).thenReturn("valuee");
- other = new RuleGroup(rules, order, contractTenant, contract, subjectOther);
- Assert.assertEquals(-1, ruleGroup.compareTo(other));
+ other = new RuleGroup(rules, order, contractTenant, contract, subjectNameComesLater);
+ assertEquals(-1, ruleGroup.compareTo(other));
}
@Test
- public void toStringTest() {
+ public void testToString() {
String string = ruleGroup.toString();
- Assert.assertNotNull(string);
- Assert.assertFalse(string.isEmpty());
- Assert.assertTrue(string.contains(rules.toString()));
- Assert.assertTrue(string.contains(order.toString()));
+ assertNotNull(string);
+ assertFalse(string.isEmpty());
+ assertTrue(string.contains(rules.toString()));
+ assertTrue(string.contains(order.toString()));
}
}
\r
package org.opendaylight.groupbasedpolicy.resolver.validator;\r
\r
-import org.junit.Assert;\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertTrue;\r
+\r
import org.junit.Before;\r
import org.junit.Rule;\r
import org.junit.Test;\r
@Rule\r
public ExpectedException thrown = ExpectedException.none();\r
\r
+ public static final String VALIDATED = "Validated.";\r
+ public static final String EMPTY_STRING = "";\r
+\r
ValidationResultBuilder resultBuilder;\r
- ValidationResult result;\r
\r
@Before\r
- public void initialisation() {\r
+ public void init() {\r
resultBuilder = new ValidationResultBuilder();\r
}\r
\r
@Test\r
- public void successValidationTest() {\r
- result = resultBuilder.success().build();\r
- Assert.assertTrue(result.isValid());\r
- Assert.assertTrue(result.getMessage().equals(""));\r
+ public void testBuild_WithSuccess() {\r
+ ValidationResult result = resultBuilder.success().build();\r
+ assertTrue(result.isValid());\r
+ assertEquals(EMPTY_STRING, result.getMessage());\r
}\r
\r
@Test\r
- public void unsuccessValidationTest() {\r
- result = resultBuilder.failed().build();\r
- Assert.assertFalse(result.isValid());\r
- Assert.assertTrue(result.getMessage().equals(""));\r
+ public void testBuild_WithFailed() {\r
+ ValidationResult result = resultBuilder.failed().build();\r
+ assertFalse(result.isValid());\r
+ assertEquals(EMPTY_STRING, result.getMessage());\r
}\r
\r
@Test\r
- public void messageTest() {\r
- result = resultBuilder.setMessage("Validated.").build();\r
- Assert.assertTrue(result.getMessage().equals("Validated."));\r
+ public void testMessage() {\r
+ ValidationResult result = resultBuilder.setMessage(VALIDATED).build();\r
+\r
+ assertEquals(VALIDATED, result.getMessage());\r
+\r
thrown.expect(IllegalArgumentException.class);\r
- thrown.expectMessage("Result message cannot be set to NULL!");\r
+ thrown.expectMessage(ValidationResultBuilder.ILLEGAL_ARG_EX_MSG);\r
resultBuilder.setMessage(null);\r
}\r
\r
/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
+ *
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class DataStoreHelperTest {
+ private static final String EXCEPTION_MESSAGE = "test exception";
+
private ReadOnlyTransaction readTransaction;
private WriteTransaction writeTransaction;
private ReadWriteTransaction readWriteTransaction;
private CheckedFuture<Optional<?>, ReadFailedException> readFuture;
private CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
- @SuppressWarnings("unchecked")
@Before
- public void initialise() {
+ public void init() {
readTransaction = mock(ReadOnlyTransaction.class);
readFuture = mock(CheckedFuture.class);
- when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
- readFuture);
+ when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(readFuture);
writeTransaction = mock(WriteTransaction.class);
submitFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(submitFuture);
readWriteTransaction = mock(ReadWriteTransaction.class);
- when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
- readFuture);
+ when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(readFuture);
}
- @SuppressWarnings({"unchecked", "rawtypes"})
@Test
- public void readFromDsTest() throws Exception {
+ public void testReadFromDs() throws Exception {
Optional<?> optional = mock(Optional.class);
when(readFuture.checkedGet()).thenReturn((Optional) optional);
Assert.assertEquals(optional, DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
mock(InstanceIdentifier.class), readTransaction));
}
- @SuppressWarnings("unchecked")
@Test
- public void readFromDsTestException() throws Exception {
- @SuppressWarnings("unused")
- Optional<?> optional = mock(Optional.class);
- doThrow(mock(ReadFailedException.class)).when(readFuture).checkedGet();
+ public void testReadFromDs_Exception() throws Exception {
+ doThrow(new ReadFailedException(EXCEPTION_MESSAGE)).when(readFuture).checkedGet();
Assert.assertEquals(Optional.absent(), DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
mock(InstanceIdentifier.class), readTransaction));
}
@Test
- public void submitToDsTest() {
+ public void testSubmitToDs() {
Assert.assertTrue(DataStoreHelper.submitToDs(writeTransaction));
}
@Test
- public void submitToDsTestException() throws Exception {
- doThrow(mock(TransactionCommitFailedException.class)).when(submitFuture).checkedGet();
+ public void testSubmitToDs_Exception() throws Exception {
+ doThrow(new TransactionCommitFailedException(EXCEPTION_MESSAGE)).when(submitFuture).checkedGet();
Assert.assertFalse(DataStoreHelper.submitToDs(writeTransaction));
}
- @SuppressWarnings({"unchecked", "rawtypes"})
@Test
- public void removeIfExistsTest() throws Exception {
+ public void testRemoveIfExists() throws Exception {
Optional<?> optional = mock(Optional.class);
when(optional.isPresent()).thenReturn(true);
when(readFuture.checkedGet()).thenReturn((Optional) optional);
verify(readWriteTransaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
}
- @SuppressWarnings({"unchecked", "rawtypes"})
@Test
- public void removeIfExistsTestException() throws Exception {
+ public void testRemoveIfExists_NotExisting() throws Exception {
Optional<?> optional = mock(Optional.class);
when(optional.isPresent()).thenReturn(false);
when(readFuture.checkedGet()).thenReturn((Optional) optional);
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.ExternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.ExternalLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.relative.location.relative.locations.InternalLocationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.interests.followed.tenants.FollowedTenant;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.interests.followed.tenants.followed.tenant.FollowedEndpointGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class IidFactoryTest {
private final String IP_ADDRESS = "192.68.50.71";
private final String IP_PREFIX = "192.168.50.0/24";
private final String L3_CONTEXT_ID = "l3Context";
+ private final String CONNECTOR = "connector";
private TenantId tenantId;
private EndpointGroupId epgId;
private RuleName ruleName;
private RendererName rendererName;
+ private InstanceIdentifier<Node> nodeIid = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, new NodeKey(new NodeId("node"))).build();
+ private InstanceIdentifier<NodeConnector> connectorIid = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, new NodeKey(new NodeId("node")))
+ .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("connector")))
+ .build();
+
@Before
public void initialise() {
tenantId = mock(TenantId.class);
InstanceIdentifier<ProviderAddressEndpointLocation> identifier = IidFactory
.providerAddressEndpointLocationIid(LOCATION_PROVIDER_NAME, IpPrefixType.class, IP_ADDRESS,
org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- l3Context)
- .build();
+ l3Context);
Assert.assertEquals(LOCATION_PROVIDER_NAME,
identifier.firstKeyOf(LocationProvider.class).getProvider().getValue());
Assert.assertEquals(IP_ADDRESS, identifier.firstKeyOf(ProviderAddressEndpointLocation.class).getAddress());
public void testAddressEndpointIid() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
InstanceIdentifier<AddressEndpoint> identifier =
- IidFactory.addressEndpointIid(new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, new ContextId(l3Context),
+ IidFactory.addressEndpointIid(new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, l3Context,
org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class
));
Assert.assertEquals(IpPrefixType.class, identifier.firstKeyOf(AddressEndpoint.class).getAddressType());
identifier.firstKeyOf(AddressEndpoint.class).getContextType());
Assert.assertEquals(l3Context, identifier.firstKeyOf(AddressEndpoint.class).getContextId());
}
+
+ @Test
+ public void testAddressEndpointLocationIid() {
+ ContextId l3Context = new ContextId(L3_CONTEXT_ID);
+ AddressEndpointLocationKey addrEndpointLocationKey =
+ new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ InstanceIdentifier<AddressEndpointLocation> iid = IidFactory.addressEndpointLocationIid(addrEndpointLocationKey);
+ Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
+ Assert.assertEquals(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
+ iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
+ }
+
+ @Test
+ public void testContainmentEndpointLocationIid() {
+ ContextId l3Context = new ContextId(L3_CONTEXT_ID);
+ ContainmentEndpointLocationKey contEndpointLocationKey =
+ new ContainmentEndpointLocationKey(l3Context,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ InstanceIdentifier<ContainmentEndpointLocation> iid = IidFactory.containmentEndpointLocationIid(contEndpointLocationKey);
+ Assert.assertEquals(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
+ iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
+ Assert.assertEquals(l3Context, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextId());
+ }
+
+ @Test
+ public void internalLocationIid_AddrEndpoint() {
+ ContextId l3Context = new ContextId(L3_CONTEXT_ID);
+ AddressEndpointLocationKey addrEndpointLocationKey =
+ new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ InternalLocationKey internalLocationKey = new InternalLocationKey(nodeIid, connectorIid);
+ InstanceIdentifier<InternalLocation> iid = IidFactory.internalLocationIid(addrEndpointLocationKey, internalLocationKey);
+ Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
+ Assert.assertEquals(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
+ iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
+ Assert.assertEquals(nodeIid, iid.firstKeyOf(InternalLocation.class).getInternalNode());
+ Assert.assertEquals(connectorIid, iid.firstKeyOf(InternalLocation.class).getInternalNodeConnector());
+ }
+
+ @Test
+ public void internalLocationIid_ContEndpoint() {
+ ContextId l3Context = new ContextId(L3_CONTEXT_ID);
+ ContainmentEndpointLocationKey contEndpointLocationKey =
+ new ContainmentEndpointLocationKey(l3Context,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ InternalLocationKey internalLocationKey = new InternalLocationKey(nodeIid, connectorIid);
+ InstanceIdentifier<InternalLocation> iid = IidFactory.internalLocationIid(contEndpointLocationKey, internalLocationKey);
+ Assert.assertEquals(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
+ iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
+ Assert.assertEquals(l3Context, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextId());
+ Assert.assertEquals(nodeIid, iid.firstKeyOf(InternalLocation.class).getInternalNode());
+ Assert.assertEquals(connectorIid, iid.firstKeyOf(InternalLocation.class).getInternalNodeConnector());
+ }
+
+ @Test
+ public void externalLocationIid_AddrEndpoint() {
+ ContextId l3Context = new ContextId(L3_CONTEXT_ID);
+ AddressEndpointLocationKey addrEndpointLocationKey =
+ new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ ExternalLocationKey externalLocationKey = new ExternalLocationKey(CONNECTOR, nodeIid);
+ InstanceIdentifier<ExternalLocation> iid = IidFactory.externalLocationIid(addrEndpointLocationKey, externalLocationKey);
+ Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
+ Assert.assertEquals(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
+ iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
+ Assert.assertEquals(CONNECTOR, iid.firstKeyOf(ExternalLocation.class).getExternalNodeConnector());
+ Assert.assertEquals(nodeIid, iid.firstKeyOf(ExternalLocation.class).getExternalNodeMountPoint());
+ }
+
+ @Test
+ public void externalLocationIid_ContEndpoint() {
+ ContextId l3Context = new ContextId(L3_CONTEXT_ID);
+ ContainmentEndpointLocationKey addrEndpointLocationKey =
+ new ContainmentEndpointLocationKey(l3Context,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ ExternalLocationKey externalLocationKey = new ExternalLocationKey(CONNECTOR, nodeIid);
+ InstanceIdentifier<ExternalLocation> iid = IidFactory.externalLocationIid(addrEndpointLocationKey, externalLocationKey);
+ Assert.assertEquals(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
+ iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
+ Assert.assertEquals(l3Context, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextId());
+ Assert.assertEquals(CONNECTOR, iid.firstKeyOf(ExternalLocation.class).getExternalNodeConnector());
+ Assert.assertEquals(nodeIid, iid.firstKeyOf(ExternalLocation.class).getExternalNodeMountPoint());
+ }
+
+ @Test
+ public void absoluteLocationIid() {
+ ContextId l3Context = new ContextId(L3_CONTEXT_ID);
+ AddressEndpointLocationKey addrEndpointLocationKey =
+ new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ InstanceIdentifier<AbsoluteLocation> iid = IidFactory.absoluteLocationIid(addrEndpointLocationKey);
+ Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
+ Assert.assertEquals(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
+ iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
+ }
}
package org.opendaylight.groupbasedpolicy.util;
-import java.util.Arrays;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class SetUtilsTest {
private Object key;
- private Object value;
private Set<Object> nestedSet;
private ConcurrentMap<Object, Set<Object>> concurrentMap;
@Before
- public void initialise() {
+ public void init() {
key = new Object();
- value = new Object();
- nestedSet = new HashSet<Object>(Arrays.asList(value));
- concurrentMap = new ConcurrentHashMap<Object, Set<Object>>();
+ nestedSet = new HashSet<>(Collections.singletonList(new Object()));
+ concurrentMap = new ConcurrentHashMap<>();
}
@Test
- public void getNestedSetTest() {
+ public void testGetNestedSet() {
concurrentMap.put(key, nestedSet);
Set<Object> inner = SetUtils.getNestedSet(key, concurrentMap);
- Assert.assertEquals(nestedSet, inner);
+ assertEquals(nestedSet, inner);
}
@Test
- public void getNestedSetTestInnerNull() {
+ public void testGetNestedSet_InnerNull() {
Set<Object> inner = SetUtils.getNestedSet(key, concurrentMap);
- Assert.assertTrue(inner.isEmpty());
+ assertTrue(inner.isEmpty());
}
}
import org.opendaylight.groupbasedpolicy.util.NetUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.location.RealLocation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.location.RealLocationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.location.real.location.location.type.RegularLocationCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElements;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElementsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElement;
&& endpoint.getAddressType().isAssignableFrom(IpPrefixType.class) && NetUtils
.samePrefix(new IpPrefix(endpoint.getAddress().toCharArray()), en.getIpPrefix())) {
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
- InstanceIdentifier<RealLocation> iid = IidFactory
+ InstanceIdentifier<AbsoluteLocation> iid = IidFactory
.providerAddressEndpointLocationIid(NE_LOCATION_PROVIDER_NAME, IpPrefixType.class,
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
- .child(RealLocation.class)
- .build();
+ .child(AbsoluteLocation.class);
wtx.put(LogicalDatastoreType.OPERATIONAL, iid, createRealLocation(ne.getIid(), iface.getIid()),
true);
wtx.submit();
&& endpoint.getAddressType().isAssignableFrom(IpPrefixType.class) && NetUtils
.samePrefix(new IpPrefix(endpoint.getAddress().toCharArray()), en.getIpPrefix())) {
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
- InstanceIdentifier<RealLocation> iid = IidFactory
+ InstanceIdentifier<AbsoluteLocation> iid = IidFactory
.providerAddressEndpointLocationIid(NE_LOCATION_PROVIDER_NAME, IpPrefixType.class,
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
- .child(RealLocation.class)
- .build();
+ .child(AbsoluteLocation.class);
wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
wtx.submit();
LOG.debug("Location deleted for endpoint {}", endpoint);
for (NetworkElement ne : nullToEmpty(nes.getNetworkElement())) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en, ne.getIid(), iface.getIid());
+ processDeletedEN(en);
}
}
}
for (NetworkElement ne : nullToEmpty(nes.getNetworkElement())) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en, ne.getIid(), iface.getIid());
+ processDeletedEN(en);
}
}
}
NetworkElement ne = netElement.getDataBefore();
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en, ne.getIid(), iface.getIid());
+ processDeletedEN(en);
}
}
networkElements.getNetworkElement().remove(ne);
if (ne != null) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en, ne.getIid(), iface.getIid());
+ processDeletedEN(en);
}
}
networkElements.getNetworkElement().remove(ne);
case DELETE: {
Interface iface = modifiedInterface.getDataBefore();
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en, nodeBefore.getIid(), iface.getIid());
+ processDeletedEN(en);
}
int nodeIndex = getIndexOf(nodeBefore);
networkElements.getNetworkElement().get(nodeIndex).getInterface().remove(iface);
int nodeIndex = getIndexOf(nodeBefore);
if (iface != null) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en, nodeBefore.getIid(), iface.getIid());
+ processDeletedEN(en);
}
networkElements.getNetworkElement().get(nodeIndex).getInterface().remove(iface);
}
NetworkElement nodeBefore, Interface ifaceBefore) {
switch (modifiedEN.getModificationType()) {
case DELETE: {
- processDeletedEN(modifiedEN.getDataBefore(), nodeBefore.getIid(), ifaceBefore.getIid());
+ processDeletedEN(modifiedEN.getDataBefore());
int nodeIndex = getIndexOf(nodeBefore);
int ifaceIndex = getIndexOf(ifaceBefore, nodeIndex);
networkElements.getNetworkElement()
&& endpoint.getContextId().equals(en.getL3ContextId())
&& endpoint.getAddressType().isAssignableFrom(IpPrefixType.class)
&& NetUtils.samePrefix(new IpPrefix(endpoint.getAddress().toCharArray()), en.getIpPrefix())) {
- InstanceIdentifier<RealLocation> iid = IidFactory
+ InstanceIdentifier<AbsoluteLocation> iid = IidFactory
.providerAddressEndpointLocationIid(NE_LOCATION_PROVIDER_NAME, IpPrefixType.class,
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
- .child(RealLocation.class)
- .build();
+ .child(AbsoluteLocation.class);
wtx.put(LogicalDatastoreType.OPERATIONAL, iid, createRealLocation(nodeIID, connectorIID), true);
wtx.submit();
LOG.debug("New location created for endpoint {}", endpoint);
}
}
- private void processDeletedEN(EndpointNetwork en, InstanceIdentifier<?> nodeIID,
- InstanceIdentifier<?> connectorIID) {
+ private void processDeletedEN(EndpointNetwork en) {
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
for (AddressEndpoint endpoint : endpoints) {
if (endpoint.getContextType().isAssignableFrom(L3Context.class)
&& endpoint.getContextId().equals(en.getL3ContextId())
&& endpoint.getAddressType().isAssignableFrom(IpPrefixType.class)
&& NetUtils.samePrefix(new IpPrefix(endpoint.getAddress().toCharArray()), en.getIpPrefix())) {
- InstanceIdentifier<RealLocation> iid = IidFactory
+ InstanceIdentifier<AbsoluteLocation> iid = IidFactory
.providerAddressEndpointLocationIid(NE_LOCATION_PROVIDER_NAME, IpPrefixType.class,
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
- .child(RealLocation.class)
- .build();
+ .child(AbsoluteLocation.class);
wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
wtx.submit();
LOG.debug("Location deleted for endpoint {}", endpoint);
}
}
- private RealLocation createRealLocation(InstanceIdentifier<?> node, InstanceIdentifier<?> iface) {
- return new RealLocationBuilder()
- .setLocationType(new RegularLocationCaseBuilder().setNode(node).setNodeConnector(iface).build()).build();
+ private AbsoluteLocation createRealLocation(InstanceIdentifier<?> node, InstanceIdentifier<?> iface) {
+ return new AbsoluteLocationBuilder()
+ .setLocationType(new InternalLocationCaseBuilder().setInternalNode(node).setInternalNodeConnector(iface).build()).build();
}
private <T> List<T> nullToEmpty(@Nullable List<T> list) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
public void test_AddressEndpointWrite_NoNE_Overwrite() throws Exception {
test_AddressEndpointWrite_NoNE_NoOverwrite();
NetworkContainment nc = new NetworkContainmentBuilder()
- .setNetworkDomainId(new NetworkDomainId(L3_CONTEXT_ID))
+ .setContainment(new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(L3_CONTEXT_ID)).build())
.build();
InstanceIdentifier<NetworkContainment> iid = InstanceIdentifier
.builder(Endpoints.class)
<?xml version="1.0" encoding="UTF-8"?>
-<!-- Copyright (c) 2015 Cisco Systems. All rights reserved.
- This program and the accompanying materials are made available under the
- terms of the Eclipse Public License v1.0 which accompanies this distribution,
+<!-- Copyright (c) 2015 Cisco Systems. All rights reserved.
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
and is available at http://www.eclipse.org/legal/epl-v10.html -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<artifactId>powermock-api-mockito</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>com.sun.jersey.jersey-test-framework</groupId>
+ <artifactId>jersey-test-framework-grizzly2</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
}
endpointManager = new EndpointManager(dataBroker, epRendererAugmentationRegistry);
endpointListener = new EndpointListener(dataBroker, endpointManager);
- this.resolvedPolicyListener = new ResolvedPolicyListener(dataBroker, endpointManager.getIovisorModuleManager());
- this.resolvedEndpointListener = new IovisorResolvedEndpointListener(dataBroker);
+ resolvedPolicyListener = new ResolvedPolicyListener(dataBroker, endpointManager.getIovisorModuleManager());
+ resolvedEndpointListener = new IovisorResolvedEndpointListener(dataBroker);
classifierDefinitionListener = new ClassifierDefinitionListener(dataBroker);
actionDefinitionListener = new ActionDefinitionListener(dataBroker);
public class ClassificationResult {
+ static final String DEFAULT_ERROR_MESSAGE = "";
private final String errorMessage;
private final boolean isSuccessful;
* @param matches cannot be {@code null}
*/
public ClassificationResult(List<String> matches) {
- errorMessage = "";
+ errorMessage = DEFAULT_ERROR_MESSAGE;
this.isSuccessful = true;
}
import java.util.List;
import java.util.Map;
+import com.google.common.collect.ImmutableList;
import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.parameter.value.RangeValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.IntBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.RangeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValue;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported.range.value.fields.SupportedRangeValueBuilder;
-import com.google.common.collect.ImmutableList;
-
/**
* Match against TCP or UDP, and source and/or destination ports
*/
public class L4Classifier extends Classifier {
+ static final String EXC_MSG_PARAM_VALUE_NOT_SPECIFIED = "Value of parameter not specified: ";
+ static final String EXC_MSG_MUT_EXCLUSIVE_PARAMS = "Mutually exclusive parameters: ";
+ static final String EXC_MSG_RANGE_VALUE_MISMATCH = "Range value mismatch: ";
+
protected L4Classifier(Classifier parent) {
super(parent);
}
if (params.get(portParam) != null) {
StringBuilder paramLog = new StringBuilder();
if (params.get(portParam).getIntValue() == null) {
- paramLog.append("Value of ").append(portParam).append(" parameter is not specified.");
+ paramLog.append(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED).append(portParam);
throw new IllegalArgumentException(paramLog.toString());
}
if (params.get(portRangeParam) != null) {
- paramLog.append("Source port parameters ")
- .append(portParam)
- .append(" and ")
- .append(portRangeParam)
- .append(" are mutually exclusive.");
+ paramLog.append(EXC_MSG_MUT_EXCLUSIVE_PARAMS).append(portParam).append(" and ").append(portRangeParam);
throw new IllegalArgumentException(paramLog.toString());
}
}
private void validateRange(Map<String, ParameterValue> params, String portRangeParam) {
if (params.get(portRangeParam) != null) {
- validateRangeValue(params.get(portRangeParam).getRangeValue());
- }
- }
-
- private void validateRangeValue(RangeValue rangeValueParam) {
- if (rangeValueParam == null) {
- throw new IllegalArgumentException("Range parameter is specifiet but value is not present.");
- }
- final Long min = rangeValueParam.getMin();
- final Long max = rangeValueParam.getMax();
- if (min > max) {
- throw new IllegalArgumentException("Range value mismatch. " + min + " is greater than MAX " + max + ".");
+ if (params.get(portRangeParam).getRangeValue() == null) {
+ throw new IllegalArgumentException(EXC_MSG_PARAM_VALUE_NOT_SPECIFIED + portRangeParam);
+ }
+ Long min = params.get(portRangeParam).getRangeValue().getMin();
+ Long max = params.get(portRangeParam).getRangeValue().getMax();
+ if (min > max) {
+ throw new IllegalArgumentException(EXC_MSG_RANGE_VALUE_MISMATCH + min + ">" + max);
+ }
}
}
package org.opendaylight.groupbasedpolicy.renderer.iovisor;
+import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
import org.junit.Before;
+import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry;
dataBroker = getDataBroker();
epRendererAugReg = mock(EpRendererAugmentationRegistry.class);
policyValidatorRegistry = mock(PolicyValidatorRegistry.class);
- iovisorRenderer = new IovisorRenderer(dataBroker, epRendererAugReg, policyValidatorRegistry);
+ iovisorRenderer = spy(new IovisorRenderer(dataBroker, epRendererAugReg, policyValidatorRegistry));
}
+
+ @Test
+ public void testConstructor() throws Exception{
+ IovisorRenderer other = new IovisorRenderer(dataBroker, epRendererAugReg, policyValidatorRegistry);
+ other.close();
+ }
+
+ @Test
+ public void testGetResolvedEndpointListener(){
+ assertNotNull(iovisorRenderer.getResolvedEndpointListener());
+ }
+
+ @Test
+ public void testGetEndPointManager(){
+ assertNotNull(iovisorRenderer.getEndPointManager());
+ }
+
}
package org.opendaylight.groupbasedpolicy.renderer.iovisor;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.iovisor.test.GbpIovisorDataBrokerTest;
+import org.opendaylight.groupbasedpolicy.renderer.iovisor.utils.IovisorIidFactory;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.IovisorResolvedEndpointsByTenantByEndpointgroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.IovisorResolvedEndpointsByTenantByEndpointgroupIdBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.iovisor.resolved.endpoints.by.tenant.by.endpointgroup.id.IovisorResolvedEndpointByTenantByEndpointgroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.iovisor.resolved.endpoints.by.tenant.by.endpointgroup.id.IovisorResolvedEndpointByTenantByEndpointgroupIdBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.interests.followed.tenants.followed.tenant.FollowedEndpointGroup;
-
-import com.google.common.base.Optional;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class IovisorResolvedEndpointListenerTest extends GbpIovisorDataBrokerTest {
private DataBroker dataBroker;
private IovisorResolvedEndpointListener iovisorResolvedEndpointListener;
+ private DataObjectModification<IovisorResolvedEndpointsByTenantByEndpointgroupId> rootNode;
+ private Set<DataTreeModification<IovisorResolvedEndpointsByTenantByEndpointgroupId>> changes;
+ private InstanceIdentifier<IovisorResolvedEndpointsByTenantByEndpointgroupId> rootIdentifier;
+
private final TenantId tenant1 = new TenantId("tenant1");
private final EndpointGroupId epg1 = new EndpointGroupId("client");
@Before
public void iovisorInit() {
dataBroker = getDataBroker();
- iovisorResolvedEndpointListener = new IovisorResolvedEndpointListener(dataBroker);
+ iovisorResolvedEndpointListener = spy(new IovisorResolvedEndpointListener(dataBroker));
+
+ rootNode = mock(DataObjectModification.class);
+ rootIdentifier = IovisorIidFactory.iovisorResolvedEndpointsByTenantIdByEndpointGroupIdWildCardIid();
+ DataTreeIdentifier<IovisorResolvedEndpointsByTenantByEndpointgroupId> rootPath =
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ IovisorIidFactory.iovisorResolvedEndpointsByTenantIdByEndpointGroupIdWildCardIid());
+ DataTreeModification<IovisorResolvedEndpointsByTenantByEndpointgroupId> change = mock(DataTreeModification.class);
+ when(change.getRootNode()).thenReturn(rootNode);
+ when(change.getRootPath()).thenReturn(rootPath);
+
+ changes = ImmutableSet.of(change);
+
+ IovisorResolvedEndpointByTenantByEndpointgroupId testElement = new IovisorResolvedEndpointByTenantByEndpointgroupIdBuilder()
+ .setTenantId(tenant1)
+ .setEndpointgroupId(epg1)
+ .build();
+ List<IovisorResolvedEndpointByTenantByEndpointgroupId> list = ImmutableList.of(testElement);
+
+ IovisorResolvedEndpointsByTenantByEndpointgroupId testData = new IovisorResolvedEndpointsByTenantByEndpointgroupIdBuilder()
+ .setIovisorResolvedEndpointByTenantByEndpointgroupId(list)
+ .build();
+
+ when(rootNode.getDataAfter()).thenReturn(testData);
}
+ @Test
+ public void testOnWrite() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);
+
+ iovisorResolvedEndpointListener.onDataTreeChanged(changes);
+
+ verify(iovisorResolvedEndpointListener).onSubtreeModified(rootNode, rootIdentifier);
+ }
+
+ @Test(expected = UnsupportedOperationException.class)
+ public void testOnDelete() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);
+
+ iovisorResolvedEndpointListener.onDataTreeChanged(changes);
+ }
+
+ @Test
+ public void testOnSubtreeModified() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+
+ iovisorResolvedEndpointListener.onDataTreeChanged(changes);
+
+ verify(iovisorResolvedEndpointListener).endpointPolicyUpdated(any(TenantId.class), any(EndpointGroupId.class), any(WriteTransaction.class));
+ }
+
+
@Test
public void endpointPolicyUpdatedTest() {
iovisorResolvedEndpointListener.endpointPolicyUpdated(tenant1, epg1, dataBroker.newWriteOnlyTransaction());
package org.opendaylight.groupbasedpolicy.renderer.iovisor;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
+import java.util.Set;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.sun.jersey.api.client.ClientHandlerException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
import org.opendaylight.groupbasedpolicy.renderer.iovisor.endpoint.EndpointManager;
import org.opendaylight.groupbasedpolicy.renderer.iovisor.module.IovisorModuleManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.iovisor.module.instances.IovisorModuleInstanceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.iovisor.modules.by.tenant.by.endpointgroup.id.iovisor.module.by.tenant.by.endpointgroup.id.IovisorModuleInstanceId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.iovisor.modules.by.tenant.by.endpointgroup.id.iovisor.module.by.tenant.by.endpointgroup.id.IovisorModuleInstanceIdBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.ActionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRuleBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraintsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
-
-import com.google.common.collect.ImmutableList;
-import com.sun.jersey.api.client.ClientHandlerException;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class ResolvedPolicyListenerTest extends GbpIovisorDataBrokerTest {
private DataBroker dataBroker;
private ResolvedPolicyListener resolvedPolicyListener;
+ private DataObjectModification<ResolvedPolicy> rootNode;
+ private Set<DataTreeModification<ResolvedPolicy>> changes;
private TenantId tenantId = new TenantId("tenant1");
private EndpointGroupId consEpg = new EndpointGroupId("client");
endpointManager = new EndpointManager(dataBroker, mock(EpRendererAugmentationRegistry.class));
iovisorModuleManager = mock(IovisorModuleManager.class);
// iovisorModuleManager = endpointManager.getIovisorModuleManager();
- resolvedPolicyListener = new ResolvedPolicyListener(dataBroker, iovisorModuleManager);
+ resolvedPolicyListener = spy(new ResolvedPolicyListener(dataBroker, iovisorModuleManager));
+
+ ResolvedPolicyKey key = mock(ResolvedPolicyKey.class);
+ rootNode = mock(DataObjectModification.class);
+ InstanceIdentifier<ResolvedPolicy> rootIdentifier =
+ InstanceIdentifier.builder(ResolvedPolicies.class)
+ .child(ResolvedPolicy.class, key)
+ .build();
+ DataTreeIdentifier<ResolvedPolicy> rootPath =
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);
+ DataTreeModification<ResolvedPolicy> change = mock(DataTreeModification.class);
+
+ when(change.getRootNode()).thenReturn(rootNode);
+ when(change.getRootPath()).thenReturn(rootPath);
+
+ changes = ImmutableSet.of(change);
+
+ when(rootNode.getDataAfter()).thenReturn(resolvedPolicy);
}
@Test(expected = NullPointerException.class)
resolvedPolicyListener.processResolvedPolicyNotification(null);
}
+ @Test
+ public void testOnWrite() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);
+
+ resolvedPolicyListener.onDataTreeChanged(changes);
+
+ verify(resolvedPolicyListener).processResolvedPolicyNotification(eq(resolvedPolicy));
+ }
+
+ @Test(expected = UnsupportedOperationException.class)
+ public void testOnDelete() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);
+
+ resolvedPolicyListener.onDataTreeChanged(changes);
+ }
+
+ @Test(expected = UnsupportedOperationException.class)
+ public void testOnSubtreeModified() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+
+ resolvedPolicyListener.onDataTreeChanged(changes);
+ }
+
@Test
public void policyUriBuilderTest() {
String target = "/restconf/operational/resolved-policy:resolved-policies/resolved-policy/" + tenantId.getValue()
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.endpoint;\r
+\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.util.IidFactory;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class EndpointListenerCovrgTest {\r
+\r
+ private EndpointListener listener;\r
+ private DataObjectModification<EndpointL3> rootNode;\r
+ private Set<DataTreeModification<EndpointL3>> changes;\r
+\r
+ private InstanceIdentifier<EndpointL3> rootIdentifier;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+ DataBroker dataProvider = mock(DataBroker.class);\r
+\r
+ EndpointManager endpointManager = mock(EndpointManager.class);\r
+ listener = spy(new EndpointListener(dataProvider, endpointManager));\r
+\r
+ EndpointL3 endpointL3 = mock(EndpointL3.class);\r
+\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = IidFactory.l3EndpointsIidWildcard();\r
+ DataTreeIdentifier<EndpointL3> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, rootIdentifier);\r
+\r
+ DataTreeModification<EndpointL3> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(endpointL3);\r
+ when(rootNode.getDataAfter()).thenReturn(endpointL3);\r
+ }\r
+\r
+ @Test\r
+ public void testOnWrite() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+\r
+ listener.onDataTreeChanged(changes);\r
+ }\r
+\r
+ @Test(expected = UnsupportedOperationException.class)\r
+ public void testOnDelete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+\r
+ listener.onDataTreeChanged(changes);\r
+ }\r
+\r
+ @Test\r
+ public void testOnSubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ listener.onDataTreeChanged(changes);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.endpoint;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;\r
+import org.opendaylight.groupbasedpolicy.renderer.iovisor.test.GbpIovisorDataBrokerTest;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.iovisor.rev151030.IovisorModuleAugmentationInput;\r
+\r
+public class IovisorEndpointAugCovrgTest extends GbpIovisorDataBrokerTest {\r
+\r
+ private EpRendererAugmentationRegistry epRAR;\r
+ private IovisorEndpointAug aug;\r
+\r
+ @Before\r
+ public void init() {\r
+ epRAR = mock(EpRendererAugmentationRegistry.class);\r
+\r
+ aug = new IovisorEndpointAug(epRAR);\r
+ }\r
+\r
+ @Test\r
+ public void testClose() throws Exception {\r
+ IovisorEndpointAug other = new IovisorEndpointAug(epRAR);\r
+ other.close();\r
+\r
+ verify(epRAR).unregister(any(IovisorEndpointAug.class));\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointAugmentation() {\r
+ assertNull(aug.buildEndpointAugmentation(null));\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointL3Augmentation() {\r
+ RegisterEndpointInput input = mock(RegisterEndpointInput.class);\r
+ IovisorModuleAugmentationInput iomAugInput = mock(IovisorModuleAugmentationInput.class);\r
+ when(input.getAugmentation(IovisorModuleAugmentationInput.class)).thenReturn(iomAugInput);\r
+ assertNotNull(aug.buildEndpointL3Augmentation(input));\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointL3Augmentation_Null() {\r
+ RegisterEndpointInput input = mock(RegisterEndpointInput.class);\r
+ when(input.getAugmentation(IovisorModuleAugmentationInput.class)).thenReturn(null);\r
+ assertNull(aug.buildEndpointL3Augmentation(input));\r
+ }\r
+\r
+ @Test\r
+ public void testBuildL3PrefixEndpointAugmentation() {\r
+ assertNull(aug.buildL3PrefixEndpointAugmentation(null));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionKey;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ActionDefinitionListenerTest {\r
+\r
+ private ActionDefinitionListener listener;\r
+ private DataObjectModification<ActionDefinition> rootNode;\r
+ private Set<DataTreeModification<ActionDefinition>> changes;\r
+\r
+ private InstanceIdentifier<ActionDefinition> rootIdentifier;\r
+ private DataBroker dataProvider;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+ dataProvider = mock(DataBroker.class);\r
+\r
+ listener = spy(new ActionDefinitionListener(dataProvider));\r
+\r
+ ActionDefinitionKey key = mock(ActionDefinitionKey.class);\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier =\r
+ InstanceIdentifier.builder(SubjectFeatureDefinitions.class).child(ActionDefinition.class, key).build();\r
+ DataTreeIdentifier<ActionDefinition> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ActionDefinition> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ActionDefinition def = new ActionDefinitionBuilder().setId(AllowActionDefinition.ID).build();\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(def);\r
+ when(rootNode.getDataAfter()).thenReturn(def);\r
+ }\r
+\r
+ @Test\r
+ public void testOnWrite() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDelete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onDelete(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnSubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+ private WriteTransaction resetTransaction() {\r
+ WriteTransaction wt = mock(WriteTransaction.class);\r
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);\r
+ when(wt.submit()).thenReturn(checkedFuture);\r
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);\r
+ return wt;\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertTrue;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.ValidationResult;\r
+import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstanceBuilder;\r
+\r
+public class AllowActionTest {\r
+\r
+ AllowAction action;\r
+\r
+ @Before\r
+ public void init() {\r
+ action = new AllowAction();\r
+ }\r
+\r
+ @Test\r
+ public void testGetId() {\r
+ assertEquals(action.getId(), AllowActionDefinition.ID);\r
+ }\r
+\r
+ @Test\r
+ public void testGetActionDef() {\r
+ assertEquals(action.getActionDef(), AllowActionDefinition.DEFINITION);\r
+ }\r
+\r
+ @Test\r
+ public void testGetSupportedParameterValues() {\r
+ assertTrue(action.getSupportedParameterValues().isEmpty());\r
+ }\r
+\r
+ @Test\r
+ public void testValidate() {\r
+ ActionInstance actionInstance = new ActionInstanceBuilder().build();\r
+ ValidationResult result = action.validate(actionInstance);\r
+ assertTrue(result.isValid());\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertTrue;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+public class ClassificationResultTest {\r
+\r
+ private static final String ERROR_MESSAGE = "error message";\r
+ private ClassificationResult resultOk;\r
+ private ClassificationResult resultError;\r
+\r
+ @Before\r
+ public void init() {\r
+ List<String> list = new ArrayList<>();\r
+ list.add("string");\r
+ resultOk = new ClassificationResult(list);\r
+ resultError = new ClassificationResult(ERROR_MESSAGE);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor_Result() {\r
+ assertTrue(resultOk.isSuccessfull());\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor_ErrorMsg() {\r
+ assertFalse(resultError.isSuccessfull());\r
+ }\r
+\r
+ @Test\r
+ public void testGetErrorMessage() {\r
+ assertEquals(resultOk.getErrorMessage(), ClassificationResult.DEFAULT_ERROR_MESSAGE);\r
+ assertEquals(resultError.getErrorMessage(), ERROR_MESSAGE);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionKey;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ClassifierDefinitionListenerTest {\r
+\r
+ private ClassifierDefinitionListener listener;\r
+ private DataObjectModification<ClassifierDefinition> rootNode;\r
+ private Set<DataTreeModification<ClassifierDefinition>> changes;\r
+\r
+ private InstanceIdentifier<ClassifierDefinition> rootIdentifier;\r
+ private DataBroker dataProvider;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+ dataProvider = mock(DataBroker.class);\r
+\r
+ listener = spy(new ClassifierDefinitionListener(dataProvider));\r
+\r
+ ClassifierDefinitionKey key = mock(ClassifierDefinitionKey.class);\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(SubjectFeatureDefinitions.class)\r
+ .child(ClassifierDefinition.class, key)\r
+ .build();\r
+ DataTreeIdentifier<ClassifierDefinition> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ClassifierDefinition> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ClassifierDefinition def = new ClassifierDefinitionBuilder().setId(EtherTypeClassifierDefinition.ID).build();\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(def);\r
+ when(rootNode.getDataAfter()).thenReturn(def);\r
+ }\r
+\r
+ @Test\r
+ public void testOnWrite() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDelete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onDelete(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnSubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+ private WriteTransaction resetTransaction() {\r
+ WriteTransaction wt = mock(WriteTransaction.class);\r
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);\r
+ when(wt.submit()).thenReturn(checkedFuture);\r
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);\r
+ return wt;\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.HashMap;\r
+import java.util.List;\r
+import java.util.Map;\r
+\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;\r
+\r
+public class EtherTypeClassifierTest {\r
+\r
+ @Test\r
+ public void testGetId() {\r
+ assertEquals(EtherTypeClassifierDefinition.ID, Classifier.ETHER_TYPE_CL.getId());\r
+ }\r
+\r
+ @Test\r
+ public void testGetClassifierDefinition() {\r
+ assertEquals(EtherTypeClassifierDefinition.DEFINITION, Classifier.ETHER_TYPE_CL.getClassifierDefinition());\r
+ }\r
+\r
+ @Test\r
+ public void testGetSupportedParameterValues() {\r
+ List<SupportedParameterValues> valuesList = Classifier.ETHER_TYPE_CL.getSupportedParameterValues();\r
+ assertEquals(1, valuesList.size());\r
+\r
+ SupportedParameterValues values = valuesList.get(0);\r
+ assertNotNull(values);\r
+ assertEquals(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, values.getParameterName().getValue());\r
+ ParameterType pt = values.getParameterType();\r
+ assertTrue(pt instanceof Int);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams() {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ ParameterValue pv = new ParameterValueBuilder().setIntValue(EtherTypeClassifierDefinition.ARP_VALUE).build();\r
+ params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, pv);\r
+\r
+ try {\r
+ Classifier.ETHER_TYPE_CL.checkPresenceOfRequiredParams(params);\r
+ } catch (IllegalArgumentException e) {\r
+ fail("Required parameter missing");\r
+ }\r
+ }\r
+\r
+ @Test(expected = IllegalArgumentException.class)\r
+ public void testCheckPresenceOfRequiredParams_noParam() {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+\r
+ Classifier.ETHER_TYPE_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test(expected = IllegalArgumentException.class)\r
+ public void testCheckPresenceOfRequiredParams_nullValue() {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ ParameterValue pv = new ParameterValueBuilder().build();\r
+ params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, pv);\r
+\r
+ Classifier.ETHER_TYPE_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testGetParent() {\r
+ assertNull(Classifier.ETHER_TYPE_CL.getParent());\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.HashMap;\r
+import java.util.List;\r
+import java.util.Map;\r
+\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;\r
+\r
+public class IpProtoClassifierTest {\r
+\r
+ @Test\r
+ public void testGetId() {\r
+ assertEquals(IpProtoClassifierDefinition.ID, Classifier.IP_PROTO_CL.getId());\r
+ }\r
+\r
+ @Test\r
+ public void testGetClassifierDefinition() {\r
+ assertEquals(IpProtoClassifierDefinition.DEFINITION, Classifier.IP_PROTO_CL.getClassifierDefinition());\r
+ }\r
+\r
+ @Test\r
+ public void testGetSupportedParameterValues() {\r
+ List<SupportedParameterValues> valuesList = Classifier.IP_PROTO_CL.getSupportedParameterValues();\r
+ assertEquals(1, valuesList.size());\r
+\r
+ SupportedParameterValues values = valuesList.get(0);\r
+ assertNotNull(values);\r
+ assertEquals(IpProtoClassifierDefinition.PROTO_PARAM, values.getParameterName().getValue());\r
+ ParameterType pt = values.getParameterType();\r
+ assertTrue(pt instanceof Int);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams() {\r
+ Map<String, ParameterValue> params = prepareParams(IpProtoClassifierDefinition.UDP_VALUE);\r
+\r
+ try {\r
+ Classifier.IP_PROTO_CL.checkPresenceOfRequiredParams(params);\r
+ } catch (IllegalArgumentException e) {\r
+ fail("Required parameter missing");\r
+ }\r
+ }\r
+\r
+ @Test(expected = IllegalArgumentException.class)\r
+ public void testCheckPresenceOfRequiredParams_noParam() {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+\r
+ Classifier.IP_PROTO_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test(expected = IllegalArgumentException.class)\r
+ public void testCheckPresenceOfRequiredParams_nullValue() {\r
+ Map<String, ParameterValue> params = prepareParams_nullValue();\r
+\r
+ Classifier.IP_PROTO_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testGetIpProtoValue() {\r
+ Long expected = IpProtoClassifierDefinition.UDP_VALUE;\r
+\r
+ assertEquals(expected, IpProtoClassifier.getIpProtoValue(prepareParams(expected)));\r
+ }\r
+\r
+ @Test\r
+ public void testGetIpProtoValue_badParams() {\r
+ Map<String, ParameterValue> params = prepareParams_nullValue();\r
+\r
+ assertNull(IpProtoClassifier.getIpProtoValue(params));\r
+ assertNull(IpProtoClassifier.getIpProtoValue(new HashMap<String, ParameterValue>()));\r
+ assertNull(IpProtoClassifier.getIpProtoValue(null));\r
+ }\r
+\r
+ @Test\r
+ public void testGetParent() {\r
+ assertEquals(Classifier.IP_PROTO_CL.getParent(), Classifier.ETHER_TYPE_CL);\r
+ }\r
+\r
+ private Map<String, ParameterValue> prepareParams(Long intValue) {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ ParameterValue pv = new ParameterValueBuilder().setIntValue(intValue).build();\r
+ params.put(IpProtoClassifierDefinition.PROTO_PARAM, pv);\r
+ return params;\r
+ }\r
+\r
+ private Map<String, ParameterValue> prepareParams_nullValue() {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ ParameterValue pv = new ParameterValueBuilder().build();\r
+ params.put(IpProtoClassifierDefinition.PROTO_PARAM, pv);\r
+ return params;\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+\r
+import java.util.HashMap;\r
+import java.util.List;\r
+import java.util.Map;\r
+\r
+import org.junit.Before;\r
+import org.junit.Rule;\r
+import org.junit.Test;\r
+import org.junit.rules.ExpectedException;\r
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.parameter.value.RangeValueBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.ParameterType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.Int;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;\r
+\r
+public class L4ClassifierTest {\r
+\r
+ private ParameterValue pvSrcPort80;\r
+ private ParameterValue pvDstPort80;\r
+ private ParameterValue pvDstPort_null;\r
+ private ParameterValue pvSrcRange81_82;\r
+ private ParameterValue pvDstRange81_82;\r
+ private ParameterValue pvDstRange82_81;\r
+ private ParameterValue pvDstRange_null;\r
+\r
+ @Rule\r
+ public ExpectedException thrown = ExpectedException.none();\r
+\r
+ @Before\r
+ public void init() {\r
+ pvSrcPort80 = new ParameterValueBuilder().setName(\r
+ new ParameterName(L4ClassifierDefinition.SRC_PORT_PARAM)).setIntValue(80L).build();\r
+ pvDstPort80 = new ParameterValueBuilder().setName(\r
+ new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).setIntValue(80L).build();\r
+ pvDstPort_null = new ParameterValueBuilder().setName(\r
+ new ParameterName(L4ClassifierDefinition.DST_PORT_PARAM)).build();\r
+ pvSrcRange81_82 = new ParameterValueBuilder().setName(\r
+ new ParameterName(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM))\r
+ .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build())\r
+ .build();\r
+ pvDstRange81_82 = new ParameterValueBuilder().setName(\r
+ new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))\r
+ .setRangeValue(new RangeValueBuilder().setMin(81L).setMax(82L).build())\r
+ .build();\r
+ pvDstRange82_81 = new ParameterValueBuilder().setName(\r
+ new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))\r
+ .setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build())\r
+ .build();\r
+ pvDstRange_null = new ParameterValueBuilder().setName(\r
+ new ParameterName(L4ClassifierDefinition.DST_PORT_RANGE_PARAM))\r
+ //.setRangeValue(new RangeValueBuilder().setMin(82L).setMax(81L).build())\r
+ .build();\r
+ }\r
+\r
+ @Test\r
+ public void testGetId() {\r
+ assertEquals(L4ClassifierDefinition.ID, Classifier.L4_CL.getId());\r
+ }\r
+\r
+ @Test\r
+ public void testGetClassifierDefinition() {\r
+ assertEquals(L4ClassifierDefinition.DEFINITION, Classifier.L4_CL.getClassifierDefinition());\r
+ }\r
+\r
+ @Test\r
+ public void testGetSupportedParameterValues() {\r
+ List<SupportedParameterValues> valuesList = Classifier.L4_CL.getSupportedParameterValues();\r
+ assertEquals(4, valuesList.size());\r
+\r
+ SupportedParameterValues values = valuesList.get(0);\r
+ assertNotNull(values);\r
+ assertEquals(L4ClassifierDefinition.SRC_PORT_PARAM, values.getParameterName().getValue());\r
+ ParameterType pt = values.getParameterType();\r
+ assertTrue(pt instanceof Int);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_Empty() throws Exception {\r
+ // TODO check: sending empty map is ok?\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap<String, ParameterValue>());\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_SinglePorts() throws Exception {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+ params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort80);\r
+\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_PortRanges() throws Exception {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82);\r
+ params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange81_82);\r
+\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_DstPortNull() throws IllegalArgumentException {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+ params.put(L4ClassifierDefinition.DST_PORT_PARAM, pvDstPort_null);\r
+\r
+ thrown.expect(IllegalArgumentException.class);\r
+ thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED);\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_DstRangeNull() throws IllegalArgumentException {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+ params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange_null);\r
+\r
+ thrown.expect(IllegalArgumentException.class);\r
+ thrown.expectMessage(L4Classifier.EXC_MSG_PARAM_VALUE_NOT_SPECIFIED);\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_ParamConflict() throws IllegalArgumentException {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+ params.put(L4ClassifierDefinition.SRC_PORT_RANGE_PARAM, pvSrcRange81_82);\r
+\r
+ thrown.expect(IllegalArgumentException.class);\r
+ thrown.expectMessage(L4Classifier.EXC_MSG_MUT_EXCLUSIVE_PARAMS);\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_RangeInverted() throws IllegalArgumentException {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ params.put(L4ClassifierDefinition.SRC_PORT_PARAM, pvSrcPort80);\r
+ params.put(L4ClassifierDefinition.DST_PORT_RANGE_PARAM, pvDstRange82_81);\r
+\r
+ thrown.expect(IllegalArgumentException.class);\r
+ thrown.expectMessage(L4Classifier.EXC_MSG_RANGE_VALUE_MISMATCH);\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(params);\r
+ }\r
+\r
+ @Test\r
+ public void testCheckPresenceOfRequiredParams_emptyParams() {\r
+\r
+ Classifier.L4_CL.checkPresenceOfRequiredParams(new HashMap<String, ParameterValue>());\r
+ }\r
+\r
+ @Test\r
+ public void testGetParent() {\r
+ assertEquals(Classifier.L4_CL.getParent(), Classifier.IP_PROTO_CL);\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertTrue;\r
+\r
+import java.util.HashMap;\r
+import java.util.List;\r
+import java.util.Map;\r
+\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;\r
+\r
+public class ParamDerivatorTest {\r
+\r
+ private ParamDerivator derivator = ParamDerivator.ETHER_TYPE_DERIVATOR;\r
+\r
+ @Test\r
+ public void testDeriveParameter_noDerivation() {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ ParameterValue pv = new ParameterValueBuilder().setIntValue(EtherTypeClassifierDefinition.IPv4_VALUE).build();\r
+ params.put(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, pv);\r
+\r
+ List<Map<String, ParameterValue>> result = derivator.deriveParameter(params);\r
+\r
+ assertEquals(1, result.size());\r
+ assertEquals(params, result.get(0));\r
+ }\r
+\r
+ @Test\r
+ public void testDeriveParameter_withDerivation() {\r
+ Map<String, ParameterValue> params = new HashMap<>();\r
+ ParameterValue pv = new ParameterValueBuilder().setIntValue(EtherTypeClassifierDefinition.IPv4_VALUE).build();\r
+ params.put("dummy key", pv);\r
+\r
+ List<Map<String, ParameterValue>> derivedParams = derivator.deriveParameter(params);\r
+\r
+ assertEquals(2, derivedParams.size());\r
+\r
+ Map<String, ParameterValue> ipv4Params = derivedParams.get(0);\r
+ Map<String, ParameterValue> ipv6Params = derivedParams.get(1);\r
+\r
+ assertTrue(ipv4Params.containsKey(EtherTypeClassifierDefinition.ETHERTYPE_PARAM));\r
+ assertTrue(ipv6Params.containsKey(EtherTypeClassifierDefinition.ETHERTYPE_PARAM));\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.iovisor.sf;\r
+\r
+import static junit.framework.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;\r
+\r
+public class SubjectFeaturesTest {\r
+\r
+ @Test\r
+ public void testGetClassifier() {\r
+ assertEquals(Classifier.ETHER_TYPE_CL, SubjectFeatures.getClassifier(EtherTypeClassifierDefinition.ID));\r
+ assertEquals(Classifier.IP_PROTO_CL, SubjectFeatures.getClassifier(IpProtoClassifierDefinition.ID));\r
+ assertEquals(Classifier.L4_CL, SubjectFeatures.getClassifier(L4ClassifierDefinition.ID));\r
+ }\r
+\r
+ @Test\r
+ public void testGetActions() {\r
+ assertNotNull(SubjectFeatures.getActions());\r
+ }\r
+\r
+ @Test\r
+ public void testGetAction() {\r
+ Assert.assertEquals(AllowActionDefinition.DEFINITION,\r
+ SubjectFeatures.getAction(AllowActionDefinition.ID).getActionDef());\r
+ }\r
+\r
+}\r
package org.opendaylight.groupbasedpolicy.renderer.restclient;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
import java.util.List;
+import com.sun.jersey.api.container.grizzly2.GrizzlyServerFactory;
+import com.sun.jersey.api.core.ClassNamesResourceConfig;
+import com.sun.jersey.api.core.ResourceConfig;
+import com.sun.jersey.test.framework.AppDescriptor;
+import com.sun.jersey.test.framework.JerseyTest;
+import com.sun.jersey.test.framework.WebAppDescriptor;
+import org.glassfish.grizzly.http.server.HttpServer;
+import org.junit.AfterClass;
import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.groupbasedpolicy.renderer.iovisor.restclient.RestClient;
-import com.google.common.collect.ImmutableList;
-
-public class RestClientTest {
+public class RestClientTest extends JerseyTest {
private RestClient client;
private String uri;
- private String resolvedPolicy =
+ private static String resolvedPolicy =
" { \"resolved-policy-uri\" : \"/restconf/operational/resolved-policy:resolved-policies/resolved-policy/tenant-red/client/tenant-red/webserver/\" } ";
+ private static final String BASE_URI = "http://localhost";
+ private static final int BASE_PORT = 1234;
+ private static HttpServer server;
+
+ private static HttpServer startServer() throws IOException {
+ final ResourceConfig resourceConfig = new ClassNamesResourceConfig(dumbServer.class);
+ HttpServer httpServer = null;
+ httpServer = GrizzlyServerFactory.createHttpServer(URI.create(BASE_URI + ":" + BASE_PORT), resourceConfig);
+ return httpServer;
+ }
+
+ @BeforeClass
+ public static void setUpClass() throws IOException {
+ server = startServer();
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ if (server != null && server.isStarted())
+ server.stop();
+ }
+
+ @Before
+ public void init() {
+ client = new RestClient("http://localhost:1234");
+ }
+
+ @Test
+ public void testResolvedPoliciesJSON_coverage() {
+ client.new ResolvedPoliciesJSON("string");
+
+ List<String> uris = new ArrayList<>();
+ uris.add("string1");
+ uris.add("string2");
+ client.new ResolvedPoliciesJSON(uris);
+ }
+
+ @Test
+ public void testGet_coverage() {
+ client.get("/");
+ client.get("/warning");
+ client.get("/error");
+ }
+
+ @Test
+ public void testPost_coverage() {
+ client.post("/", "json");
+ }
+
+ @Override
+ protected AppDescriptor configure() {
+ return new WebAppDescriptor.Builder().build();
+ }
+
+ @Path("/")
+ public static class dumbServer {
+
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response get200() {
+ return Response.status(Response.Status.OK).entity(resolvedPolicy).build();
+ }
+
+ @POST
+ @Consumes(MediaType.APPLICATION_JSON)
+ public Response post200(String json) {
+ return Response.status(Response.Status.OK).build();
+ }
+
+ @Path("/warning")
+ @GET
+ public Response get202() {
+ return Response.status(Response.Status.ACCEPTED).build();
+ }
+
+ @Path("/error")
+ @GET
+ public Response get404() {
+ return Response.status(Response.Status.NOT_FOUND).build();
+ }
+
+ }
}
// TODO missing impl for case when classifier is changed or removed
}
- private Map<InstanceIdentifier<Classifier>, Classifier> resolveClassifiers(ResolvedPolicy resolvedPolicy,
+ // TODO move to some util class
+ public static Map<InstanceIdentifier<Classifier>, Classifier> resolveClassifiers(ResolvedPolicy resolvedPolicy,
InstanceIdentifier<ResolvedPolicy> resolvedPolicyIid) {
List<PolicyRuleGroupWithEndpointConstraints> policyRgWithEcs =
resolvedPolicy.getPolicyRuleGroupWithEndpointConstraints();
private static final Pattern REPLACE_PATTERN = Pattern.compile("^\\w+:(\\w+):.*");
static final String API_FLOW = "/flow/";
static final String SUFFIX_JSON = "/json";
+ static final String KEYS_SPLIT_REGEX = ",";
private transient Direction direction;
private String name;
private String[] keyNames;
private int keyNum;
- private FlowCache() {
- }
+ private FlowCache() {}
private FlowCache(FlowCacheBuilder builder) {
this.name = builder.getName();
this.definition = builder.getDefinition();
this.direction = builder.getDirection();
- this.keyNames = this.definition.getKeys().split(",");
+ this.keyNames = this.definition.getKeys().split(KEYS_SPLIT_REGEX);
this.keyNum = this.keyNames.length;
for (int i = 0; i < this.keyNum; i++) {
keyNames[i] = parseNullableKeyName(keyNames[i]);
public static class FlowCacheDefinitionBuilder {
- private String value;
+ private String value = "";
private boolean log = false;
private final FlowCacheKeysBuilder keysBuilder = new FlowCacheKeysBuilder();
private final FlowCacheFilterBuilder filterBuilder = new FlowCacheFilterBuilder();
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;
import java.util.List;
+import java.util.Objects;
import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;
public static FlowCache createFlowCache(InstanceIdentifier<Classifier> classifierIid, Classifier classifier,
FlowCacheCons.Value value) {
- FlowCacheDefinition flowCacheDefinition = creteFlowCacheDefinition(classifier, value);
+ FlowCacheDefinition flowCacheDefinition = createFlowCacheDefinition(classifier, value);
if (flowCacheDefinition == null) {
LOG.info("Cannot create flow cache for statistics of classifier {}\n{}", classifierIid, classifier);
return null;
.build();
}
- public static FlowCacheDefinition creteFlowCacheDefinition(Classifier classifier, FlowCacheCons.Value value) {
+ public static FlowCacheDefinition createFlowCacheDefinition(Classifier classifier,
+ FlowCacheCons.Value value) {
FlowCacheDefinitionBuilder fcdBuilder = new FlowCacheDefinitionBuilder();
if (L4ClassifierDefinition.ID.equals(classifier.getClassifierDefinitionId())) {
addEthTypeInfoToFlowCache(classifier, fcdBuilder);
private static boolean addTcpUdpPortKeys(Long ipProto, Long port, boolean isDstPort,
FlowCacheDefinitionBuilder fcdBuilder) {
if (isDstPort) {
- if (ipProto == IpProtoClassifierDefinition.TCP_VALUE) {
+ if (Objects.equals(ipProto, IpProtoClassifierDefinition.TCP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.TCP_DST_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.TCP_DST_PORT.get() + FlowCacheCons.EQ + port);
- } else if (ipProto == IpProtoClassifierDefinition.UDP_VALUE) {
+ } else if (Objects.equals(ipProto, IpProtoClassifierDefinition.UDP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.UDP_DST_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.UDP_DST_PORT.get() + FlowCacheCons.EQ + port);
} else {
return false;
}
} else {
- if (ipProto == IpProtoClassifierDefinition.TCP_VALUE) {
+ if (Objects.equals(ipProto, IpProtoClassifierDefinition.TCP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.TCP_SRC_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.TCP_SRC_PORT.get() + FlowCacheCons.EQ + port);
- } else if (ipProto == IpProtoClassifierDefinition.UDP_VALUE) {
+ } else if (Objects.equals(ipProto, IpProtoClassifierDefinition.UDP_VALUE)) {
fcdBuilder.getKeysBuilder().addValue(FlowCacheCons.Key.UDP_SRC_PORT.get());
fcdBuilder.getFilterBuilder().addValue(FlowCacheCons.Key.UDP_SRC_PORT.get() + FlowCacheCons.EQ + port);
} else {
return values;
}
+ /**
+ * Sets FlowCache's "key" values by copying {@code String}s from {@code values},
+ * to avoid immutable list put as a parameter.
+ * {@code null}s are omitted.
+ *
+ * @param values List of String
+ * @return FlowCacheKeysBuilder
+ */
public FlowCacheKeysBuilder setValues(List<String> values) {
- this.values = Preconditions.checkNotNull(values);
+ Preconditions.checkNotNull(values);
+ for (String value : values) {
+ if (value != null) {
+ this.values.add(value);
+ }
+ }
return this;
}
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.DataChangeListenerTester;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
private InstanceIdentifier<DataObject> endpointId;
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
private EndpointManager endpointManager;
- private EndpointManagerListener endpointManagerListener;
+ private DataChangeListenerTester tester;
@SuppressWarnings("unchecked")
@Before
public void init() {
endpointId = mock(InstanceIdentifier.class);
- change = mock(AsyncDataChangeEvent.class);
endpointManager = mock(EndpointManager.class);
- endpointId = mock(InstanceIdentifier.class);
DataBroker dataProvider = mock(DataBroker.class);
- endpointManagerListener = new EndpointManagerListener(dataProvider, endpointManager);
- Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
- removedPaths.add(endpointId);
- when(change.getRemovedPaths()).thenReturn(removedPaths);
+
+ EndpointManagerListener endpointManagerListener =
+ new EndpointManagerListener(dataProvider, endpointManager);
+ tester = new DataChangeListenerTester(endpointManagerListener);
+ tester.setRemovedPath(endpointId);
}
@Test
public void testOnDataChangeEndpoint() {
DataObject endpoint = mock(Endpoint.class);
+ tester.setDataObject(endpointId, endpoint);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(endpointId, endpoint);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ tester.callOnDataChanged();
- endpointManagerListener.onDataChanged(change);
verify(endpointManager, times(3)).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class),
+ any(EndpointL3.class));
}
@Test
public void testOnDataChangeEndpointL3() {
DataObject endpoint = mock(EndpointL3.class);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(endpointId, endpoint);
+ tester.setDataObject(endpointId, endpoint);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ tester.callOnDataChanged();
- endpointManagerListener.onDataChanged(change);
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, times(3)).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ verify(endpointManager, times(3)).processL3Endpoint(any(EndpointL3.class),
+ any(EndpointL3.class));
}
@Test
public void testOnDataChangeEndpointL3Prefix() {
DataObject endpoint = mock(EndpointL3Prefix.class);
- Map<InstanceIdentifier<?>, DataObject> testData = new HashMap<>();
- testData.put(endpointId, endpoint);
+ tester.setDataObject(endpointId, endpoint);
- when(change.getCreatedData()).thenReturn(testData);
- when(change.getOriginalData()).thenReturn(testData);
- when(change.getUpdatedData()).thenReturn(testData);
+ tester.callOnDataChanged();
- endpointManagerListener.onDataChanged(change);
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class),
+ any(EndpointL3.class));
}
-}
\ No newline at end of file
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Matchers.eq;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinitionKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinition;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ActionDefinitionListenerTest {\r
+\r
+ private ActionDefinitionListener listener;\r
+ private DataObjectModification<ActionDefinition> rootNode;\r
+ private Set<DataTreeModification<ActionDefinition>> changes;\r
+\r
+ private DataBroker dataProvider;\r
+\r
+ private InstanceIdentifier<ActionDefinition> rootIdentifier;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+\r
+ dataProvider = mock(DataBroker.class);\r
+\r
+ listener = spy(new ActionDefinitionListener(dataProvider));\r
+\r
+ ActionDefinitionKey key = mock(ActionDefinitionKey.class);\r
+\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(SubjectFeatureDefinitions.class)\r
+ .child(ActionDefinition.class, key)\r
+ .build();\r
+ DataTreeIdentifier<ActionDefinition> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ActionDefinition> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ActionDefinition def = new ActionDefinitionBuilder().setId(AllowActionDefinition.ID).build();\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(def);\r
+ when(rootNode.getDataAfter()).thenReturn(def);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Write() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedActionDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_SubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedActionDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Delete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));\r
+ }\r
+\r
+ private WriteTransaction resetTransaction() {\r
+ WriteTransaction wt = mock(WriteTransaction.class);\r
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);\r
+ when(wt.submit()).thenReturn(checkedFuture);\r
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);\r
+ return wt;\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Matchers.eq;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinitionKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ClassifierDefinitionListenerTest {\r
+\r
+ private ClassifierDefinitionListener listener;\r
+ private DataObjectModification<ClassifierDefinition> rootNode;\r
+ private Set<DataTreeModification<ClassifierDefinition>> changes;\r
+\r
+ private DataBroker dataProvider;\r
+\r
+ private InstanceIdentifier<ClassifierDefinition> rootIdentifier;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+\r
+ dataProvider = mock(DataBroker.class);\r
+\r
+ listener = spy(new ClassifierDefinitionListener(dataProvider));\r
+\r
+ ClassifierDefinitionKey key = mock(ClassifierDefinitionKey.class);\r
+\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(SubjectFeatureDefinitions.class)\r
+ .child(ClassifierDefinition.class, key)\r
+ .build();\r
+ DataTreeIdentifier<ClassifierDefinition> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ClassifierDefinition> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ClassifierDefinition def =\r
+ new ClassifierDefinitionBuilder().setId(EtherTypeClassifierDefinition.ID).build();\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(def);\r
+ when(rootNode.getDataAfter()).thenReturn(def);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Write() {\r
+ when(rootNode.getModificationType()).thenReturn(\r
+ DataObjectModification.ModificationType.WRITE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedClassifierDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_SubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(\r
+ DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).put(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),\r
+ any(SupportedClassifierDefinition.class), eq(true));\r
+ }\r
+\r
+ @Test\r
+ public void testOnDataTreeChanged_Delete() {\r
+ when(rootNode.getModificationType()).thenReturn(\r
+ DataObjectModification.ModificationType.DELETE);\r
+\r
+ WriteTransaction wt = resetTransaction();\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(wt).delete(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));\r
+ }\r
+\r
+ private WriteTransaction resetTransaction() {\r
+ WriteTransaction wt = mock(WriteTransaction.class);\r
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);\r
+ when(wt.submit()).thenReturn(checkedFuture);\r
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);\r
+ return wt;\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Mockito.mock;\r
+\r
+import java.util.concurrent.ScheduledExecutorService;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
+\r
+public class OFStatisticsManagerTest {\r
+\r
+ ScheduledExecutorService executor;\r
+ StatisticsManager statisticsManager;\r
+\r
+ @Before\r
+ public void init() {\r
+ executor = mock(ScheduledExecutorService.class);\r
+ statisticsManager = mock(StatisticsManager.class);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() throws Exception {\r
+ new OFStatisticsManager(executor, statisticsManager);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Matchers.anyMap;\r
+import static org.mockito.Matchers.anySet;\r
+import static org.mockito.Matchers.anyString;\r
+import static org.mockito.Mockito.doNothing;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.when;\r
+\r
+import javax.ws.rs.core.MultivaluedMap;\r
+\r
+import java.util.concurrent.ExecutorService;\r
+import java.util.concurrent.ScheduledExecutorService;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
+\r
+public class ReadGbpFlowCacheTaskTest {\r
+\r
+ ReadGbpFlowCacheTask task;\r
+\r
+ @Before\r
+ public void init() {\r
+ StatisticsManager statisticsManager = mock(StatisticsManager.class);\r
+ ScheduledExecutorService executor = mock(ScheduledExecutorService.class);\r
+ JsonRestClientResponse response = mock(JsonRestClientResponse.class);\r
+ when(response.getJsonResponse()).thenReturn("[{\"one\":1, \"two\":2, \"three\":3}]");\r
+ when(response.getStatusCode()).thenReturn(200);\r
+ SFlowRTConnection connection = mock(SFlowRTConnection.class);\r
+ when(connection.get(anyString(), any(MultivaluedMap.class))).thenReturn(response);\r
+ when(connection.getExecutor()).thenReturn(executor);\r
+ doNothing().when(executor).execute(any(Runnable.class));\r
+\r
+ task = new ReadGbpFlowCacheTask("cache1", connection, statisticsManager, 100, 0.1, "sum");\r
+ }\r
+\r
+ @Test\r
+ public void testRun() {\r
+\r
+ task.run();\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.ParameterValueList;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyKey;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class ResolvedPolicyClassifierListenerTest {\r
+\r
+ private ResolvedPolicyClassifierListener classifierListener;\r
+ private DataObjectModification<ResolvedPolicy> rootNode;\r
+ private Set<DataTreeModification<ResolvedPolicy>> changes;\r
+\r
+ private InstanceIdentifier<ResolvedPolicy> rootIdentifier;\r
+\r
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
+ private final ContractId contractId = new ContractId("contract1");\r
+ private final TenantId tenantId = new TenantId("tenant1");\r
+ private final ClassifierName classifierName = new ClassifierName("classifier1");\r
+ private final SubjectName subjectName = new SubjectName("subject1");\r
+ private final RuleName ruleName = new RuleName("rule1");\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+ DataBroker dataProvider = mock(DataBroker.class);\r
+ OFStatisticsManager ofStatisticsManager = mock(OFStatisticsManager.class);\r
+\r
+ classifierListener = spy(new ResolvedPolicyClassifierListener(dataProvider, ofStatisticsManager));\r
+\r
+ ResolvedPolicyKey key = mock(ResolvedPolicyKey.class);\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(ResolvedPolicies.class).child(ResolvedPolicy.class, key).build();\r
+ DataTreeIdentifier<ResolvedPolicy> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<ResolvedPolicy> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE);\r
+\r
+ Classifier classifier = new ClassifierBuilder().setName(classifierName)\r
+ .setClassifierDefinitionId(IpProtoClassifierDefinition.ID)\r
+ .setParameterValue(parameterValues)\r
+ .build();\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+ when(rootNode.getDataBefore()).thenReturn(rp);\r
+ when(rootNode.getDataAfter()).thenReturn(rp);\r
+ }\r
+\r
+ @Test\r
+ public void testOnWrite() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+\r
+ classifierListener.onDataTreeChanged(changes);\r
+\r
+ verify(classifierListener).onWrite(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDelete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+\r
+ classifierListener.onDataTreeChanged(changes);\r
+\r
+ verify(classifierListener).onDelete(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnSubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ classifierListener.onDataTreeChanged(changes);\r
+\r
+ verify(classifierListener).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
+\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.spy;\r
+import static org.mockito.Mockito.times;\r
+import static org.mockito.Mockito.verify;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.Set;\r
+import java.util.concurrent.ScheduledExecutorService;\r
+\r
+import com.google.common.collect.ImmutableSet;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.sflow.values.SflowClientSettings;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class SflowClientSettingsListenerTest {\r
+\r
+ private SflowClientSettingsListener listener;\r
+ private DataObjectModification<SflowClientSettings> rootNode;\r
+ private Set<DataTreeModification<SflowClientSettings>> changes;\r
+\r
+ private InstanceIdentifier<SflowClientSettings> rootIdentifier;\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Before\r
+ public void init() {\r
+ DataBroker dataProvider = mock(DataBroker.class);\r
+\r
+ StatisticsManager ofStatisticsManager = mock(StatisticsManager.class);\r
+ ScheduledExecutorService executor = mock(ScheduledExecutorService.class);\r
+ listener = spy(new SflowClientSettingsListener(dataProvider, executor, ofStatisticsManager));\r
+\r
+ SflowClientSettings sflowClientSettings = mock(SflowClientSettings.class);\r
+\r
+ rootNode = mock(DataObjectModification.class);\r
+ rootIdentifier = InstanceIdentifier.builder(OfOverlayConfig.class).child(SflowClientSettings.class).build();\r
+ DataTreeIdentifier<SflowClientSettings> rootPath =\r
+ new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);\r
+\r
+ DataTreeModification<SflowClientSettings> change = mock(DataTreeModification.class);\r
+\r
+ when(change.getRootNode()).thenReturn(rootNode);\r
+ when(change.getRootPath()).thenReturn(rootPath);\r
+\r
+ changes = ImmutableSet.of(change);\r
+\r
+ when(rootNode.getDataBefore()).thenReturn(sflowClientSettings);\r
+ when(rootNode.getDataAfter()).thenReturn(sflowClientSettings);\r
+ }\r
+\r
+ @Test\r
+ public void testOnWrite() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onWrite(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnDelete() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);\r
+\r
+ listener.onDataTreeChanged(changes);\r
+\r
+ verify(listener).onDelete(rootNode, rootIdentifier);\r
+ }\r
+\r
+ @Test\r
+ public void testOnSubtreeModified() {\r
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);\r
+\r
+ // first call will initialize uninitialized dependencies;\r
+ // second call will call #close on them\r
+ listener.onDataTreeChanged(changes);\r
+ listener.onDataTreeChanged(changes);\r
+ verify(listener, times(2)).onSubtreeModified(rootNode, rootIdentifier);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;\r
+\r
+public class FlowCacheBuilderTest {\r
+\r
+ private static final String NAME_1 = "name_1";\r
+ private static final Direction direction = Direction.Bidirectional;\r
+ private static final String VALUE_1 = "value_1";\r
+ private FlowCacheDefinition flowCacheDefinition;\r
+ private FlowCache.FlowCacheBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCache.FlowCacheBuilder();\r
+ flowCacheDefinition = FlowCacheDefinition.builder().setValue(VALUE_1).build();\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCache.FlowCacheBuilder b = null;\r
+ try {\r
+ b = new FlowCache.FlowCacheBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ }\r
+\r
+ @Test\r
+ public void testSetName() {\r
+ builder.setName(NAME_1);\r
+\r
+ assertEquals(NAME_1, builder.getName());\r
+ }\r
+\r
+ @Test\r
+ public void testSetDefinition() {\r
+ builder.setDefinition(flowCacheDefinition);\r
+\r
+ assertEquals(VALUE_1, builder.getDefinition().getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testSetDirection() {\r
+ builder.setDirection(direction);\r
+\r
+ assertEquals(direction, builder.getDirection());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ FlowCache cache = builder.setName(NAME_1)\r
+ .setDefinition(flowCacheDefinition)\r
+ .setDirection(direction)\r
+ .build();\r
+\r
+ assertNotNull(cache);\r
+ assertEquals(NAME_1, cache.getName());\r
+ assertEquals(flowCacheDefinition, cache.getDefinition());\r
+ assertEquals(direction, cache.getDirection());\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+public class FlowCacheDefinitionBuilderTest {\r
+\r
+ private static final String VALUE = "value-1";\r
+\r
+ private FlowCacheDefinition.FlowCacheDefinitionBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCacheDefinition.FlowCacheDefinitionBuilder();\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCacheDefinition.FlowCacheDefinitionBuilder b = null;\r
+ try {\r
+ b = new FlowCacheDefinition.FlowCacheDefinitionBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ assertFalse(b.isLog());\r
+ assertNotNull(b.getFilterBuilder());\r
+ assertNotNull(b.getKeysBuilder());\r
+ assertNotNull(b.getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testSetValue() {\r
+ builder.setValue(VALUE);\r
+ assertEquals(VALUE, builder.getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testSetLog() {\r
+ builder.setLog(true);\r
+ assertTrue(builder.isLog());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ builder.setValue(VALUE).setLog(true);\r
+ FlowCacheDefinition definition = builder.build();\r
+\r
+ assertEquals(VALUE, definition.getValue());\r
+ assertTrue(definition.getLog());\r
+ assertNotNull(definition.getKeys());\r
+ assertNotNull(definition.getFilter());\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Test;\r
+\r
+public class FlowCacheDefinitionTest {\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCacheDefinition.FlowCacheDefinitionBuilder builder = null;\r
+ try {\r
+ builder = FlowCacheDefinition.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+\r
+import java.util.Arrays;\r
+import java.util.List;\r
+\r
+import com.google.common.collect.ImmutableList;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.ResolvedPolicyClassifierListener;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.FlowCacheCons;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.IidSflowNameUtil;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.ParameterValueList;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class FlowCacheFactoryTest {\r
+\r
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
+ private final ContractId contractId = new ContractId("contract1");\r
+ private final TenantId tenantId = new TenantId("tenant1");\r
+ private final ClassifierName classifierName = ClassifierName.getDefaultInstance("classifier1");\r
+ private final SubjectName subjectName = SubjectName.getDefaultInstance("subject1");\r
+ private final RuleName ruleName = new RuleName("rule1");\r
+\r
+ private InstanceIdentifier<ResolvedPolicy> rpIid;\r
+ private String expectedName;\r
+\r
+ @Before\r
+ public void init() {\r
+ rpIid = InstanceIdentifier.create(ResolvedPolicy.class);\r
+ expectedName = tenantId.getValue() + IidSflowNameUtil.KEY_DELIMETER + contractId.getValue()\r
+ + IidSflowNameUtil.KEY_DELIMETER + subjectName.getValue() + IidSflowNameUtil.DELIMETER\r
+ + ruleName.getValue() + IidSflowNameUtil.DELIMETER + classifierName.getValue()\r
+ + IidSflowNameUtil.DELIMETER + FlowCacheCons.Value.BYTES.get();\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_EtherTypeClassifier_IPv4() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE);\r
+\r
+ Classifier classifier = newEtherTypeClassifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_IpProtoClassifier_TCP_IPv4() {\r
+\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE);\r
+\r
+ Classifier classifier = newIpProtoClassifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys =\r
+ ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(), FlowCacheCons.Key.IP_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_IpProtoClassifier_UDP_noEthertype() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addProto(IpProtoClassifierDefinition.UDP_VALUE);\r
+\r
+ Classifier classifier = newIpProtoClassifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys =\r
+ ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(), FlowCacheCons.Key.IP_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_L4Classifier_dstPort() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE)\r
+ .addDstPort((long) 80);\r
+ Classifier classifier = newL4Classifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.TCP_DST_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+\r
+ ParameterValueList parameterValuesUDP = new ParameterValueList();\r
+ parameterValuesUDP.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.UDP_VALUE)\r
+ .addDstPort((long) 80);\r
+ Classifier classifierUDP = newL4Classifier(parameterValuesUDP);\r
+ ResolvedPolicy rpUDP = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifierUDP);\r
+\r
+ FlowCache flowCacheUDP = callCreateFlowCache(rpUDP, classifierUDP);\r
+\r
+ assertNotNull(flowCacheUDP);\r
+\r
+ List<String> keysUDP = Arrays.asList(flowCacheUDP.getKeyNames());\r
+ List<String> expectedKeysUDP = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.UDP_DST_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCacheUDP.getName());\r
+ assertEquals(expectedKeysUDP.size(), keysUDP.size());\r
+ assertTrue(keysUDP.containsAll(expectedKeysUDP));\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCache_L4Classifier_srcPort() {\r
+ ParameterValueList parameterValues = new ParameterValueList();\r
+ parameterValues.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.TCP_VALUE)\r
+ .addSrcPort((long) 80);\r
+ Classifier classifier = newL4Classifier(parameterValues);\r
+ ResolvedPolicy rp = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifier);\r
+\r
+ FlowCache flowCache = callCreateFlowCache(rp, classifier);\r
+\r
+ assertNotNull(flowCache);\r
+\r
+ List<String> keys = Arrays.asList(flowCache.getKeyNames());\r
+ List<String> expectedKeys = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.TCP_SRC_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCache.getName());\r
+ assertEquals(expectedKeys.size(), keys.size());\r
+ assertTrue(keys.containsAll(expectedKeys));\r
+\r
+ ParameterValueList parameterValuesUDP = new ParameterValueList();\r
+ parameterValuesUDP.addEthertype(EtherTypeClassifierDefinition.IPv4_VALUE)\r
+ .addProto(IpProtoClassifierDefinition.UDP_VALUE)\r
+ .addSrcPort((long) 80);\r
+ Classifier classifierUDP = newL4Classifier(parameterValuesUDP);\r
+ ResolvedPolicy rpUDP = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName, consumerEpgId,\r
+ providerEpgId, classifierUDP);\r
+\r
+ FlowCache flowCacheUDP = callCreateFlowCache(rpUDP, classifierUDP);\r
+\r
+ assertNotNull(flowCacheUDP);\r
+\r
+ List<String> keysUDP = Arrays.asList(flowCacheUDP.getKeyNames());\r
+ List<String> expectedKeysUDP = ImmutableList.of(FlowCacheCons.Key.ETH_PROTOCOL.get(),\r
+ FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.UDP_SRC_PORT.get(),\r
+ FlowCacheCons.Key.IP_SOURCE.get(), FlowCacheCons.Key.IP_DESTINATION.get());\r
+\r
+ assertEquals(expectedName, flowCacheUDP.getName());\r
+ assertEquals(expectedKeysUDP.size(), keysUDP.size());\r
+ assertTrue(keysUDP.containsAll(expectedKeysUDP));\r
+ }\r
+\r
+ private Classifier newClassifier(ClassifierDefinitionId classifierDefinitionId,\r
+ ParameterValueList parameterValues) {\r
+ return new ClassifierBuilder().setName(classifierName)\r
+ .setClassifierDefinitionId(classifierDefinitionId)\r
+ .setParameterValue(parameterValues)\r
+ .build();\r
+ }\r
+\r
+ private Classifier newEtherTypeClassifier(ParameterValueList parameterValues) {\r
+ return newClassifier(EtherTypeClassifierDefinition.ID, parameterValues);\r
+ }\r
+\r
+ private Classifier newIpProtoClassifier(ParameterValueList parameterValues) {\r
+ return newClassifier(IpProtoClassifierDefinition.ID, parameterValues);\r
+ }\r
+\r
+ private Classifier newL4Classifier(ParameterValueList parameterValues) {\r
+ return newClassifier(L4ClassifierDefinition.ID, parameterValues);\r
+ }\r
+\r
+ private FlowCache callCreateFlowCache(ResolvedPolicy rp, Classifier classifier) {\r
+ return FlowCacheFactory.createFlowCache(\r
+ TestUtils.getClassifierIid(ResolvedPolicyClassifierListener.resolveClassifiers(rp, rpIid)), classifier,\r
+ FlowCacheCons.Value.BYTES);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+public class FlowCacheFilterBuilderTest {\r
+\r
+ private static final String VALUE_1 = "value_1";\r
+ private static final String VALUE_2 = "value_2";\r
+ private static final String VALUE_3 = "value_3";\r
+ private static final List<String> LIST = new ArrayList<>();\r
+\r
+ private FlowCacheFilter.FlowCacheFilterBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCacheFilter.FlowCacheFilterBuilder();\r
+ LIST.add(VALUE_1);\r
+ LIST.add(VALUE_2);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCacheFilter.FlowCacheFilterBuilder b = null;\r
+ try {\r
+ b = new FlowCacheFilter.FlowCacheFilterBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ assertNotNull(b.getValues());\r
+ assertTrue(b.getValues().isEmpty());\r
+ }\r
+\r
+ @Test\r
+ public void testSetValues() {\r
+ builder.setValues(LIST);\r
+\r
+ assertFalse(builder.getValues().isEmpty());\r
+ assertEquals(LIST.size(), builder.getValues().size());\r
+ assertEquals(LIST.get(0), builder.getValues().get(0));\r
+ }\r
+\r
+ @Test\r
+ public void testAddValue() {\r
+ builder.setValues(LIST);\r
+ int expectedSize = LIST.size() + 1;\r
+\r
+ builder.addValue(VALUE_3);\r
+\r
+ assertEquals(expectedSize, builder.getValues().size());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ builder.setValues(LIST);\r
+\r
+ FlowCacheFilter filter = builder.build();\r
+\r
+ assertTrue(filter.getValue().contains(VALUE_1));\r
+ assertTrue(filter.getValue().contains(VALUE_2));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Test;\r
+\r
+public class FlowCacheFilterTest {\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCacheFilter.FlowCacheFilterBuilder builder = null;\r
+ try {\r
+ builder = FlowCacheFilter.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+\r
+public class FlowCacheKeysBuilderTest {\r
+\r
+ private static final String VALUE_1 = "value_1";\r
+ private static final String VALUE_2 = "value_2";\r
+ private static final String VALUE_3 = "value_3";\r
+ private static final List<String> LIST = new ArrayList<>();\r
+\r
+ private FlowCacheKeys.FlowCacheKeysBuilder builder;\r
+\r
+ @Before\r
+ public void init() {\r
+ builder = new FlowCacheKeys.FlowCacheKeysBuilder();\r
+ LIST.add(VALUE_1);\r
+ LIST.add(VALUE_2);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() {\r
+ FlowCacheKeys.FlowCacheKeysBuilder b = null;\r
+ try {\r
+ b = new FlowCacheKeys.FlowCacheKeysBuilder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(b);\r
+ assertNotNull(b.getValues());\r
+ assertTrue(b.getValues().isEmpty());\r
+ }\r
+\r
+ @Test\r
+ public void testSetValues() {\r
+ builder.setValues(LIST);\r
+\r
+ assertFalse(builder.getValues().isEmpty());\r
+ assertEquals(LIST.size(), builder.getValues().size());\r
+ assertEquals(LIST.get(0), builder.getValues().get(0));\r
+ }\r
+\r
+ @Test\r
+ public void testAddValue() {\r
+ builder.setValues(LIST);\r
+ int expectedSize = LIST.size() + 1;\r
+\r
+ builder.addValue(VALUE_3);\r
+\r
+ assertEquals(expectedSize, builder.getValues().size());\r
+ }\r
+\r
+ @Test\r
+ public void testBuild() {\r
+ builder.setValues(LIST);\r
+\r
+ FlowCacheKeys keys = builder.build();\r
+\r
+ assertTrue(keys.getValue().contains(VALUE_1));\r
+ assertTrue(keys.getValue().contains(VALUE_2));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import org.junit.Test;\r
+\r
+public class FlowCacheKeysTest {\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCacheKeys.FlowCacheKeysBuilder builder = null;\r
+ try {\r
+ builder = FlowCacheKeys.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.fail;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection;\r
+\r
+public class FlowCacheTest {\r
+\r
+ private static final String KEY_1 = "key_1";\r
+ private static final String KEY_2 = "key_2";\r
+ private static final String NAME_1 = "name_1";\r
+ private static final HasDirection.Direction direction = HasDirection.Direction.Bidirectional;\r
+ private static final String VALUE_1 = "value_1";\r
+ private static FlowCacheDefinition flowCacheDefinition;\r
+ private List<String> keysValues;\r
+ private String json;\r
+\r
+ @Before\r
+ public void init() {\r
+ keysValues = new ArrayList<>();\r
+ keysValues.add(KEY_1);\r
+ keysValues.add(KEY_2);\r
+\r
+ FlowCacheDefinition.FlowCacheDefinitionBuilder flowCacheDefinitionBuilder = FlowCacheDefinition.builder();\r
+ flowCacheDefinitionBuilder.getKeysBuilder().setValues(keysValues);\r
+ flowCacheDefinition = flowCacheDefinitionBuilder.setValue(VALUE_1).setLog(true).build();\r
+\r
+ json = "{\"keys\":\"" + KEY_1 + "," + KEY_2 + "\"," + "\"value\":\"" + VALUE_1 + "\","\r
+ + "\"filter\":\"\",\"log\":true}";\r
+ }\r
+\r
+ @Test\r
+ public void testBuilder() {\r
+ FlowCache.FlowCacheBuilder builder = null;\r
+ try {\r
+ builder = FlowCache.builder();\r
+ } catch (Exception e) {\r
+ fail("Exception thrown: " + e.getMessage());\r
+ }\r
+ assertNotNull(builder);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor_Implicitely() {\r
+ FlowCache flowCache =\r
+ FlowCache.builder().setDefinition(flowCacheDefinition).setDirection(direction).setName(NAME_1).build();\r
+\r
+ assertEquals(keysValues.size(), flowCache.getKeyNum());\r
+ assertEquals(keysValues.get(0), flowCache.getKeyNames()[0]);\r
+ assertEquals(keysValues.get(1), flowCache.getKeyNames()[1]);\r
+ assertEquals(FlowCache.API_FLOW + NAME_1 + FlowCache.SUFFIX_JSON, flowCache.getPath());\r
+ assertEquals(json, flowCache.getJsonDefinition());\r
+\r
+ }\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.when;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.ResolvedPolicyClassifierListener;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class IidSflowNameUtilTest {\r
+\r
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
+ private final ContractId contractId = new ContractId("contract1");\r
+ private final TenantId tenantId = new TenantId("tenant1");\r
+ private final ClassifierName classifierName = ClassifierName.getDefaultInstance("classifier1");\r
+ private final SubjectName subjectName = SubjectName.getDefaultInstance("subject1");\r
+ private final RuleName ruleName = new RuleName("rule1");\r
+ private InstanceIdentifier<ResolvedPolicy> rpIid;\r
+ private String testName;\r
+ private ResolvedPolicy resolvedPolicy;\r
+\r
+ @Before\r
+ public void init() {\r
+ Classifier classifier = mock(Classifier.class);\r
+ when(classifier.getKey()).thenReturn(new ClassifierKey(classifierName));\r
+\r
+ resolvedPolicy = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName,\r
+ consumerEpgId, providerEpgId, classifier);\r
+\r
+ rpIid = InstanceIdentifier.create(ResolvedPolicy.class);\r
+ testName =\r
+ tenantId.getValue() + IidSflowNameUtil.KEY_DELIMETER + contractId.getValue() + IidSflowNameUtil.KEY_DELIMETER + subjectName\r
+ .getValue() + IidSflowNameUtil.DELIMETER + ruleName.getValue() + IidSflowNameUtil.DELIMETER + classifierName\r
+ .getValue() + IidSflowNameUtil.DELIMETER + FlowCacheCons.Value.BYTES.get();\r
+ }\r
+\r
+ @Test\r
+ public void testCreateFlowCacheName() {\r
+ InstanceIdentifier<Classifier> classifierIid = TestUtils.getClassifierIid(\r
+ ResolvedPolicyClassifierListener.resolveClassifiers(resolvedPolicy, rpIid));\r
+\r
+ assertEquals(testName,\r
+ IidSflowNameUtil.createFlowCacheName(classifierIid, FlowCacheCons.Value.BYTES));\r
+ }\r
+\r
+ @Test\r
+ public void testResolveContractIdFromFlowCacheName() {\r
+ assertEquals(contractId.getValue(),\r
+ IidSflowNameUtil.resolveContractIdFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveSubjectNameFromFlowCacheName() {\r
+ assertEquals(subjectName.getValue(),\r
+ IidSflowNameUtil.resolveSubjectNameFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveRuleNameFromFlowCacheName() {\r
+ assertEquals(ruleName.getValue(),\r
+ IidSflowNameUtil.resolveRuleNameFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveClassifierNameFromFlowCacheName() {\r
+ assertEquals(classifierName.getValue(),\r
+ IidSflowNameUtil.resolveClassifierNameFromFlowCacheName(testName).getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testResolveFlowCacheValue() {\r
+ assertEquals(FlowCacheCons.Value.BYTES.get(),\r
+ IidSflowNameUtil.resolveFlowCacheValue(testName));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class DataChangeListenerTester {
+
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeMock;
+ private DataChangeListener listener;
+
+ private Map<InstanceIdentifier<?>, DataObject> testData;
+ private Set<InstanceIdentifier<?>> removedPaths;
+
+ @SuppressWarnings("unchecked")
+ public DataChangeListenerTester(DataChangeListener listener) {
+ changeMock = mock(AsyncDataChangeEvent.class);
+ testData = new HashMap<>();
+ removedPaths = new HashSet<>();
+
+ this.listener = listener;
+
+ when(changeMock.getCreatedData()).thenReturn(testData);
+ when(changeMock.getOriginalData()).thenReturn(testData);
+ when(changeMock.getUpdatedData()).thenReturn(testData);
+ when(changeMock.getRemovedPaths()).thenReturn(removedPaths);
+ }
+
+ public DataChangeListenerTester setDataObject(InstanceIdentifier<DataObject> iid, DataObject dataObject){
+ testData.clear();
+ return addDataObject(iid, dataObject);
+ }
+
+ public DataChangeListenerTester addDataObject(InstanceIdentifier<DataObject> iid, DataObject dataObject){
+ testData.put(iid, dataObject);
+ return this;
+ }
+
+ public DataChangeListenerTester setRemovedPath(InstanceIdentifier<DataObject> iid){
+ removedPaths.clear();
+ return addRemovedPath(iid);
+ }
+
+ public DataChangeListenerTester addRemovedPath(InstanceIdentifier<DataObject> iid){
+ removedPaths.add(iid);
+ return this;
+ }
+
+ public void callOnDataChanged(){
+ listener.onDataChanged(changeMock);
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test;
+
+import java.util.ArrayList;
+
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.api.sf.L4ClassifierDefinition;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache.FlowCacheFactoryTest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;
+
+public class ParameterValueList extends ArrayList<ParameterValue> {
+
+ public ParameterValueList() {
+ super();
+ }
+
+ public ParameterValueList addEthertype(Long value) {
+ this.add(newParameterValue(EtherTypeClassifierDefinition.ETHERTYPE_PARAM, value));
+ return this;
+ }
+
+ public ParameterValueList addProto(Long value) {
+ this.add(newParameterValue(IpProtoClassifierDefinition.PROTO_PARAM, value));
+ return this;
+ }
+
+ public ParameterValueList addDstPort(Long value) {
+ this.add(newParameterValue(L4ClassifierDefinition.DST_PORT_PARAM, value));
+ return this;
+ }
+
+ public ParameterValueList addSrcPort(Long value) {
+ this.add(newParameterValue(L4ClassifierDefinition.SRC_PORT_PARAM, value));
+ return this;
+ }
+
+ public ParameterValue newParameterValue(String parameterName, Long intValue) {
+ return new ParameterValueBuilder().setName(new ParameterName(parameterName))
+ .setIntValue(intValue).build();
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.ImmutableList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRuleBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraintsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class TestUtils {
+
+ // taken from org.opendaylight.groupbasedpolicy.renderer.faas.FaasPolicyManagerTest
+ // by Khaldoon Al-zoubi; modified as necessary
+ public static ResolvedPolicy newResolvedPolicy(TenantId tenantId, ContractId contractId, SubjectName subjectName,
+ RuleName ruleName, EndpointGroupId consumerEpgId, EndpointGroupId providerEpgId, Classifier classifier) {
+ ResolvedPolicyBuilder builder = new ResolvedPolicyBuilder();
+ builder.setConsumerEpgId(consumerEpgId);
+ builder.setConsumerTenantId(tenantId);
+ builder.setProviderEpgId(providerEpgId);
+ builder.setProviderTenantId(tenantId);
+ List<PolicyRuleGroupWithEndpointConstraints> pRulesGrpsWEp = new ArrayList<>();
+ PolicyRuleGroupWithEndpointConstraintsBuilder pRulesGrpWEp =
+ new PolicyRuleGroupWithEndpointConstraintsBuilder();
+ List<PolicyRuleGroup> pRulesGrps = new ArrayList<>();
+ PolicyRuleGroupBuilder pRulesGrp = new PolicyRuleGroupBuilder();
+ pRulesGrp.setContractId(contractId);
+ pRulesGrp.setTenantId(tenantId);
+ pRulesGrp.setSubjectName(subjectName);
+ pRulesGrp.setResolvedRule(ImmutableList
+ .of(new ResolvedRuleBuilder().setName(ruleName).setClassifier(ImmutableList.of(classifier)).build()));
+ pRulesGrps.add(pRulesGrp.build());
+ pRulesGrpWEp.setPolicyRuleGroup(pRulesGrps);
+ pRulesGrpsWEp.add(pRulesGrpWEp.build());
+ builder.setPolicyRuleGroupWithEndpointConstraints(pRulesGrpsWEp);
+ return builder.build();
+ }
+
+ public static InstanceIdentifier<Classifier> getClassifierIid(
+ Map<InstanceIdentifier<Classifier>, Classifier> resolvedClassifiers) {
+ Map.Entry<InstanceIdentifier<Classifier>, Classifier> firstEntry =
+ resolvedClassifiers.entrySet().iterator().next();
+ return firstEntry.getKey();
+ }
+}
<module>iovisor</module>
<module>ovssfc</module>
<module>netconf</module>
+ <module>vpp</module>
</modules>
<dependencies>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy-renderers</artifactId>
+ <version>0.4.0-SNAPSHOT</version>
+ <relativePath>../</relativePath>
+ </parent>
+
+ <artifactId>vpp-renderer</artifactId>
+ <packaging>bundle</packaging>
+
+ <properties></properties>
+
+ <dependencies>
+ <!-- project specific dependencies -->
+
+ <!-- testing dependencies -->
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-all</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+ <!-- project build -->
+ <build>
+ <!-- We use the maven-resources-plugin to copy a class from the groupbasepolicy
+ bundle that we need in order to run some unit tests in the renderer (classes
+ in the test directory aren't packaged in bundles, and instead of keeping
+ separate copies, we just copy the file(s) needed in order to run the test). -->
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Export-Package>
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp.input.rev160425.*
+ </Export-Package> -->
+ </instructions>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+-->
+<snapshot>
+ <configuration>
+ <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <name>vpp-provider-impl</name>
+ <type xmlns:vpp="urn:opendaylight:params:xml:ns:yang:controller:config:vpp-provider:impl">
+ vpp:vpp-provider-impl
+ </type>
+ <data-broker>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-async-data-broker</type>
+ <name>binding-data-broker</name>
+ </data-broker>
+ </module>
+ </modules>
+ </data>
+ </configuration>
+ <required-capabilities>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:config:vpp-provider:impl?module=vpp-provider-impl&revision=2016-04-25</capability>
+ </required-capabilities>
+</snapshot>
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.config.yang.config.vpp_provider.impl;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class VppProviderModule extends org.opendaylight.controller.config.yang.config.vpp_provider.impl.AbstractVppProviderModule {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppProviderModule.class);
+
+ public VppProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public VppProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.vpp_provider.impl.VppProviderModule oldModule, java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void customValidation() {
+ // add custom validation form module attributes here.
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ final VppRenderer vppRenderer = new VppRenderer(getDataBrokerDependency());
+
+ LOG.info("VPP Renderer instance has been created");
+
+ return new AutoCloseable() {
+
+ @Override
+ public void close() throws Exception {
+ vppRenderer.close();
+ }
+ };
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+/*
+* Generated file
+*
+* Generated from: yang module name: vpp-provider-impl yang module local name: vpp-provider-impl
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Thu May 05 09:46:48 CEST 2016
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.config.vpp_provider.impl;
+public class VppProviderModuleFactory extends org.opendaylight.controller.config.yang.config.vpp_provider.impl.AbstractVppProviderModuleFactory {
+
+}
--- /dev/null
+/*\r
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.controller.config.yang.config.vpp_provider.impl;\r
+\r
+import com.google.common.base.Preconditions;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+public class VppRenderer implements AutoCloseable {\r
+ private static final Logger LOG = LoggerFactory.getLogger(VppRenderer.class);\r
+\r
+ private DataBroker dataBroker;\r
+\r
+ public VppRenderer(DataBroker dataBroker) {\r
+ Preconditions.checkNotNull(dataBroker);\r
+\r
+ this.dataBroker = dataBroker;\r
+\r
+ LOG.info("VPP Renderer has Started");\r
+ }\r
+\r
+ @Override\r
+ public void close() throws Exception {\r
+ this.dataBroker = null;\r
+ }\r
+\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+module vpp-provider-impl {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:config:vpp-provider:impl";
+ prefix "vpp-provider-impl";
+
+ import config { prefix config; revision-date 2013-04-05; }
+ import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; }
+ import ietf-yang-types { prefix "yang"; revision-date 2010-09-24; }
+ import opendaylight-sal-binding-broker-impl { prefix sal-broker; revision-date 2013-10-28;}
+ import groupbasedpolicy-cfg { prefix gbpcfg; revision-date 2015-11-06; }
+
+ description
+ "This module contains the base YANG definitions for
+ vpp-provider impl implementation.";
+
+ revision "2016-04-25" {
+ description
+ "Initial revision.";
+ }
+
+ identity vpp-provider-impl {
+ base "config:module-type";
+
+ config:java-name-prefix VppProvider;
+ }
+
+ // Augments the 'configuration' choice node under modules/module.
+ augment "/config:modules/config:module/config:configuration" {
+ case vpp-provider-impl {
+ when "/config:modules/config:module/config:type = 'vpp-provider-impl'";
+
+ // Wires in the data-broker service
+ container data-broker {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity mdsal:binding-async-data-broker;
+ }
+ }
+ }
+ }
+ }
+}
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.RegisterEndpointInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
// apply sxpMasterDB to policy template
final Ipv4Prefix address = new Ipv4Prefix(epForwardingTemplate.getIpPrefix().getIpv4Prefix().getValue());
final NetworkContainment networkContainment = new NetworkContainmentBuilder()
+ .setContainment(new NetworkDomainContainmentBuilder()
.setNetworkDomainType(epForwardingTemplate.getNetworkContainment().getNetworkDomainType())
.setNetworkDomainId(epForwardingTemplate.getNetworkContainment().getNetworkDomainId())
+ .build())
.build();
final RegisterEndpointInput epInput = new RegisterEndpointInputBuilder()
.setAddressEndpointReg(Collections.singletonList(new AddressEndpointRegBuilder()
Code Review / groupbasedpolicy.git / commitdiff