Skip to content
GitLab
Commits (19)
Expand all Hide whitespace changes
Inline Side-by-side
src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java 0 → 100644
View file @ 6963de19
/*
* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.etsi.tfs.policy.common;
import org.etsi.tfs.policy.model.PolicyRuleState;
import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
public class ApplicationProperties {
public static final String INVALID_MESSAGE = "%s is invalid.";
public static final String VALID_MESSAGE = "%s is valid.";
public static final PolicyRuleState INSERTED_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_INSERTED, "Successfully entered to INSERTED state");
public static final PolicyRuleState VALIDATED_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_VALIDATED, "Successfully transitioned to VALIDATED state");
public static final PolicyRuleState PROVISIONED_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_PROVISIONED,
"Successfully transitioned from VALIDATED to PROVISIONED state");
public static final PolicyRuleState ACTIVE_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_ACTIVE,
"Successfully transitioned from PROVISIONED to ACTIVE state");
public static final PolicyRuleState ENFORCED_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_ENFORCED,
"Successfully transitioned from ACTIVE to ENFORCED state");
public static final PolicyRuleState INEFFECTIVE_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_INEFFECTIVE,
"Transitioned from ENFORCED to INEFFECTIVE state");
public static final PolicyRuleState EFFECTIVE_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_EFFECTIVE,
"Successfully transitioned from ENFORCED to EFFECTIVE state");
public static final PolicyRuleState UPDATED_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_UPDATED, "Successfully entered to UPDATED state");
public static final PolicyRuleState REMOVED_POLICYRULE_STATE =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_REMOVED, "Successfully entered to REMOVED state");
}
src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleBasic.java
View file @ 6963de19
......@@ -64,7 +64,7 @@ public class PolicyRuleBasic {
this.booleanOperator = BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_UNDEFINED;
this.policyRuleActions = new ArrayList<PolicyRuleAction>();
this.isValid = false;
this.exceptionMessage = e.toString();
this.exceptionMessage = e.getMessage();
}
}
......
src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleDevice.java
View file @ 6963de19
......@@ -40,7 +40,7 @@ public class PolicyRuleDevice {
this.policyRuleBasic = policyRuleBasic;
this.deviceIds = new ArrayList<String>();
this.isValid = false;
this.exceptionMessage = e.toString();
this.exceptionMessage = e.getMessage();
}
}
......
src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleService.java
View file @ 6963de19
......@@ -50,7 +50,7 @@ public class PolicyRuleService {
this.serviceId = new ServiceId("", "");
this.deviceIds = new ArrayList<String>();
this.isValid = false;
this.exceptionMessage = e.toString();
this.exceptionMessage = e.getMessage();
}
}
......
src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddDeviceTest.java 0 → 100644
View file @ 6963de19
/*
* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.etsi.tfs.policy;
import static org.assertj.core.api.Assertions.assertThat;
import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE;
import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.mockito.InjectMock;
import io.smallrye.mutiny.Uni;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.inject.Inject;
import org.etsi.tfs.policy.context.ContextService;
import org.etsi.tfs.policy.model.BooleanOperator;
import org.etsi.tfs.policy.model.NumericalOperator;
import org.etsi.tfs.policy.model.PolicyRuleAction;
import org.etsi.tfs.policy.model.PolicyRuleActionConfig;
import org.etsi.tfs.policy.model.PolicyRuleActionEnum;
import org.etsi.tfs.policy.model.PolicyRuleBasic;
import org.etsi.tfs.policy.model.PolicyRuleCondition;
import org.etsi.tfs.policy.model.PolicyRuleDevice;
import org.etsi.tfs.policy.model.PolicyRuleState;
import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
import org.etsi.tfs.policy.monitoring.MonitoringService;
import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue;
import org.etsi.tfs.policy.monitoring.model.KpiValue;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@QuarkusTest
class PolicyAddDeviceTest {
@Inject PolicyServiceImpl policyService;
@InjectMock PolicyRuleConditionValidator policyRuleConditionValidator;
@InjectMock ContextService contextService;
@InjectMock MonitoringService monitoringService;
static PolicyRuleBasic policyRuleBasic;
static PolicyRuleDevice policyRuleDevice;
@BeforeAll
static void init() {
String policyId = "policyRuleId";
KpiValue kpiValue = new IntegerKpiValue(100);
PolicyRuleCondition policyRuleCondition =
new PolicyRuleCondition(
"kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue);
PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value");
PolicyRuleAction policyRuleAction =
new PolicyRuleAction(
PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION,
Arrays.asList(policyRuleActionConfig));
policyRuleBasic =
new PolicyRuleBasic(
policyId,
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
1,
Arrays.asList(policyRuleCondition),
BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
Arrays.asList(policyRuleAction));
List<String> deviceIds = Arrays.asList("device1", "device2");
policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, deviceIds);
}
@Test
void deviceListMustNotBeEmpty()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleDevice policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, new ArrayList<>());
PolicyRuleState expectedResult =
new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Device Ids must not be empty.");
policyService
.addPolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void isPolicyRuleBasicValid() throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleBasic policyRuleBasic =
new PolicyRuleBasic(
"policyId",
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
0,
new ArrayList<>(),
BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
new ArrayList<>());
PolicyRuleDevice policyRuleDevice =
new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_FAILED, "Policy Rule conditions cannot be empty.");
policyService
.addPolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void isPolicyRuleIdValid() throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleDevice policyRuleDevice =
new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_FAILED,
String.format(
INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId()));
Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString()))
.thenReturn(Uni.createFrom().item(Boolean.FALSE));
policyService
.addPolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void successPolicyDevice() throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleDevice policyRuleDevice =
new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_VALIDATED,
VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage());
Mockito.when(policyRuleConditionValidator.isDeviceIdValid(Mockito.anyString()))
.thenReturn(Uni.createFrom().item(Boolean.TRUE));
policyService
.addPolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
}
src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddServiceTest.java 0 → 100644
View file @ 6963de19
/*
* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.etsi.tfs.policy;
import static org.assertj.core.api.Assertions.assertThat;
import static org.etsi.tfs.policy.common.ApplicationProperties.*;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.mockito.InjectMock;
import io.smallrye.mutiny.Uni;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.inject.Inject;
import org.etsi.tfs.policy.context.ContextService;
import org.etsi.tfs.policy.context.model.Service;
import org.etsi.tfs.policy.context.model.ServiceId;
import org.etsi.tfs.policy.context.model.ServiceTypeEnum;
import org.etsi.tfs.policy.model.BooleanOperator;
import org.etsi.tfs.policy.model.NumericalOperator;
import org.etsi.tfs.policy.model.PolicyRule;
import org.etsi.tfs.policy.model.PolicyRuleAction;
import org.etsi.tfs.policy.model.PolicyRuleActionConfig;
import org.etsi.tfs.policy.model.PolicyRuleActionEnum;
import org.etsi.tfs.policy.model.PolicyRuleBasic;
import org.etsi.tfs.policy.model.PolicyRuleCondition;
import org.etsi.tfs.policy.model.PolicyRuleService;
import org.etsi.tfs.policy.model.PolicyRuleState;
import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
import org.etsi.tfs.policy.monitoring.MonitoringService;
import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue;
import org.etsi.tfs.policy.monitoring.model.KpiValue;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@QuarkusTest
public class PolicyAddServiceTest {
@Inject PolicyServiceImpl policyService;
@InjectMock PolicyRuleConditionValidator policyRuleConditionValidator;
@InjectMock ContextService contextService;
@InjectMock MonitoringService monitoringService;
static PolicyRuleBasic policyRuleBasic;
static PolicyRuleService policyRuleService;
@BeforeAll
static void init() {
String policyId = "policyRuleId";
KpiValue kpiValue = new IntegerKpiValue(100);
PolicyRuleCondition policyRuleCondition =
new PolicyRuleCondition(
"kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue);
PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value");
PolicyRuleAction policyRuleAction =
new PolicyRuleAction(
PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION,
Arrays.asList(policyRuleActionConfig));
policyRuleBasic =
new PolicyRuleBasic(
policyId,
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
1,
Arrays.asList(policyRuleCondition),
BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
Arrays.asList(policyRuleAction));
ServiceId serviceId = new ServiceId("contextId", "serviceId");
Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0);
List<String> deviceIds = Arrays.asList("device1", "device2");
policyRuleService = new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
}
@Test
void contextOrServiceIdMustNotBeEmpty()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
ServiceId serviceId = new ServiceId("", "");
List<String> deviceIds = Arrays.asList("device1", "device2");
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_FAILED, "Context Id of Service Id must not be empty.");
policyService
.addPolicyService(policyRuleService)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void serviceIdMustNotBeEmpty() throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
ServiceId serviceId = new ServiceId("sdf", "");
List<String> deviceIds = Arrays.asList("device1", "device2");
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
PolicyRuleState expectedResult =
new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Service Id must not be empty.");
policyService
.addPolicyService(policyRuleService)
.subscribe()
.with(item -> message.complete(item));
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void policyRuleIdMustNotBeEmpty()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
String policyId = "";
PolicyRuleBasic policyRuleBasic =
new PolicyRuleBasic(
policyId,
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
1,
new ArrayList<>(),
null,
new ArrayList<>());
ServiceId serviceId = new ServiceId("contextId", "serviceId");
Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0);
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>());
PolicyRuleState expectedResult =
new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Policy rule ID must not be empty.");
policyService
.addPolicyService(policyRuleService)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void checkMessageIfServiceIsNotValid()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
ServiceId serviceId = new ServiceId("contextId", "serviceId");
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>());
PolicyRuleState expectedResult =
new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, serviceId + " is invalid.");
Mockito.when(
policyRuleConditionValidator.isServiceIdValid(
Mockito.any(ServiceId.class), Mockito.anyList()))
.thenReturn(Uni.createFrom().item(Boolean.FALSE));
policyService
.addPolicyService(policyRuleService)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void policyServiceSuccess()
throws ExecutionException, InterruptedException, TimeoutException, IOException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_VALIDATED,
VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage());
Mockito.when(
policyRuleConditionValidator.isServiceIdValid(
Mockito.any(ServiceId.class), Mockito.anyList()))
.thenReturn(Uni.createFrom().item(Boolean.TRUE));
Mockito.when(contextService.setPolicyRule(Mockito.any(PolicyRule.class)))
.thenReturn(Uni.createFrom().item("policyRuleId"));
policyService
.addPolicyService(policyRuleService)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
}
src/policy/src/test/java/org/etsi/tfs/policy/PolicyDeleteServiceTest.java 0 → 100644
View file @ 6963de19
/*
* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.etsi.tfs.policy;
import static org.assertj.core.api.Assertions.assertThat;
import static org.etsi.tfs.policy.common.ApplicationProperties.REMOVED_POLICYRULE_STATE;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.mockito.InjectMock;
import io.smallrye.mutiny.Uni;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.inject.Inject;
import org.etsi.tfs.policy.context.ContextService;
import org.etsi.tfs.policy.context.model.Service;
import org.etsi.tfs.policy.context.model.ServiceId;
import org.etsi.tfs.policy.context.model.ServiceTypeEnum;
import org.etsi.tfs.policy.model.BooleanOperator;
import org.etsi.tfs.policy.model.NumericalOperator;
import org.etsi.tfs.policy.model.PolicyRule;
import org.etsi.tfs.policy.model.PolicyRuleAction;
import org.etsi.tfs.policy.model.PolicyRuleActionConfig;
import org.etsi.tfs.policy.model.PolicyRuleActionEnum;
import org.etsi.tfs.policy.model.PolicyRuleBasic;
import org.etsi.tfs.policy.model.PolicyRuleCondition;
import org.etsi.tfs.policy.model.PolicyRuleService;
import org.etsi.tfs.policy.model.PolicyRuleState;
import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
import org.etsi.tfs.policy.model.PolicyRuleType;
import org.etsi.tfs.policy.model.PolicyRuleTypeService;
import org.etsi.tfs.policy.monitoring.MonitoringService;
import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue;
import org.etsi.tfs.policy.monitoring.model.KpiValue;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@QuarkusTest
class PolicyDeleteServiceTest {
@Inject PolicyServiceImpl policyService;
@InjectMock ContextService contextService;
@InjectMock MonitoringService monitoringService;
static PolicyRuleBasic policyRuleBasic;
static PolicyRuleService policyRuleService;
@BeforeAll
static void init() {
String policyId = "policyRuleId";
KpiValue kpiValue = new IntegerKpiValue(100);
PolicyRuleCondition policyRuleCondition =
new PolicyRuleCondition(
"kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue);
PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value");
PolicyRuleAction policyRuleAction =
new PolicyRuleAction(
PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION,
Arrays.asList(policyRuleActionConfig));
policyRuleBasic =
new PolicyRuleBasic(
policyId,
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
1,
Arrays.asList(policyRuleCondition),
BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
Arrays.asList(policyRuleAction));
ServiceId serviceId = new ServiceId("contextId", "serviceId");
Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0);
List<String> deviceIds = Arrays.asList("device1", "device2");
policyRuleService = new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
}
@Test
void contextOrServiceIdMustNotBeEmpty()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
String policyRuleId = "";
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_REMOVED,
REMOVED_POLICYRULE_STATE.getPolicyRuleStateMessage());
PolicyRuleType policyRuleType = new PolicyRuleTypeService(policyRuleService);
PolicyRule policyRule = new PolicyRule(policyRuleType);
Mockito.when(contextService.getPolicyRule(Mockito.anyString()))
.thenReturn(Uni.createFrom().item(policyRule));
policyService
.deletePolicy(policyRuleId)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
}
src/policy/src/test/java/org/etsi/tfs/policy/PolicyServiceTest.java → src/policy/src/test/java/org/etsi/tfs/policy/PolicyGrpcServiceTest.java
View file @ 6963de19
......@@ -46,14 +46,14 @@ import policy.PolicyCondition.PolicyRuleCondition;
import policy.PolicyService;
@QuarkusTest
class PolicyServiceTest {
private static final Logger LOGGER = Logger.getLogger(PolicyServiceTest.class);
class PolicyGrpcServiceTest {
private static final Logger LOGGER = Logger.getLogger(PolicyGrpcServiceTest.class);
@GrpcClient PolicyService client;
private final Serializer serializer;
@Inject
PolicyServiceTest(Serializer serializer) {
PolicyGrpcServiceTest(Serializer serializer) {
this.serializer = serializer;
}
......
src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateDeviceTest.java 0 → 100644
View file @ 6963de19
/*
* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.etsi.tfs.policy;
import static org.assertj.core.api.Assertions.assertThat;
import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE;
import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.mockito.InjectMock;
import io.smallrye.mutiny.Uni;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.inject.Inject;
import org.etsi.tfs.policy.model.BooleanOperator;
import org.etsi.tfs.policy.model.NumericalOperator;
import org.etsi.tfs.policy.model.PolicyRuleAction;
import org.etsi.tfs.policy.model.PolicyRuleActionConfig;
import org.etsi.tfs.policy.model.PolicyRuleActionEnum;
import org.etsi.tfs.policy.model.PolicyRuleBasic;
import org.etsi.tfs.policy.model.PolicyRuleCondition;
import org.etsi.tfs.policy.model.PolicyRuleDevice;
import org.etsi.tfs.policy.model.PolicyRuleState;
import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
import org.etsi.tfs.policy.monitoring.MonitoringService;
import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue;
import org.etsi.tfs.policy.monitoring.model.KpiValue;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@QuarkusTest
class PolicyUpdateDeviceTest {
@Inject PolicyServiceImpl policyService;
@InjectMock PolicyRuleConditionValidator policyRuleConditionValidator;
@InjectMock MonitoringService monitoringService;
static PolicyRuleBasic policyRuleBasic;
static PolicyRuleDevice policyRuleDevice;
@BeforeAll
static void init() {
String policyId = "policyRuleId";
KpiValue kpiValue = new IntegerKpiValue(100);
PolicyRuleCondition policyRuleCondition =
new PolicyRuleCondition(
"kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue);
PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value");
PolicyRuleAction policyRuleAction =
new PolicyRuleAction(
PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION,
Arrays.asList(policyRuleActionConfig));
policyRuleBasic =
new PolicyRuleBasic(
policyId,
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
1,
Arrays.asList(policyRuleCondition),
BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
Arrays.asList(policyRuleAction));
List<String> deviceIds = Arrays.asList("device1", "device2");
policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, deviceIds);
}
@Test
void deviceListMustNotBeEmpty()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleDevice policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, new ArrayList<>());
PolicyRuleState expectedResult =
new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Device Ids must not be empty.");
policyService
.updatePolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void isPolicyRuleBasicValid() throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleBasic policyRuleBasic =
new PolicyRuleBasic(
"policyId",
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
0,
new ArrayList<>(),
BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
new ArrayList<>());
PolicyRuleDevice policyRuleDevice =
new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_FAILED, "Policy Rule conditions cannot be empty.");
policyService
.updatePolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void isUpdatedPolicyRuleIdValid()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleDevice policyRuleDevice =
new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_FAILED,
String.format(
INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId()));
Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString()))
.thenReturn(Uni.createFrom().item(Boolean.FALSE));
policyService
.updatePolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void successUpdatePolicyService()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
PolicyRuleDevice policyRuleDevice =
new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1"));
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_VALIDATED,
VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage());
Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString()))
.thenReturn(Uni.createFrom().item(Boolean.TRUE));
policyService
.updatePolicyDevice(policyRuleDevice)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
}
src/policy/src/test/java/org/etsi/tfs/policy/PolicyUpdateServiceTest.java 0 → 100644
View file @ 6963de19
/*
* Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.etsi.tfs.policy;
import static org.assertj.core.api.Assertions.assertThat;
import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE;
import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.mockito.InjectMock;
import io.smallrye.mutiny.Uni;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.inject.Inject;
import org.etsi.tfs.policy.context.ContextService;
import org.etsi.tfs.policy.context.model.Service;
import org.etsi.tfs.policy.context.model.ServiceId;
import org.etsi.tfs.policy.context.model.ServiceTypeEnum;
import org.etsi.tfs.policy.model.BooleanOperator;
import org.etsi.tfs.policy.model.NumericalOperator;
import org.etsi.tfs.policy.model.PolicyRuleAction;
import org.etsi.tfs.policy.model.PolicyRuleActionConfig;
import org.etsi.tfs.policy.model.PolicyRuleActionEnum;
import org.etsi.tfs.policy.model.PolicyRuleBasic;
import org.etsi.tfs.policy.model.PolicyRuleCondition;
import org.etsi.tfs.policy.model.PolicyRuleService;
import org.etsi.tfs.policy.model.PolicyRuleState;
import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
import org.etsi.tfs.policy.monitoring.MonitoringService;
import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue;
import org.etsi.tfs.policy.monitoring.model.KpiValue;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@QuarkusTest
class PolicyUpdateServiceTest {
@Inject PolicyServiceImpl policyService;
@InjectMock PolicyRuleConditionValidator policyRuleConditionValidator;
@InjectMock ContextService contextService;
@InjectMock MonitoringService monitoringService;
static PolicyRuleBasic policyRuleBasic;
static PolicyRuleService policyRuleService;
@BeforeAll
static void init() {
String policyId = "policyRuleId";
KpiValue kpiValue = new IntegerKpiValue(100);
PolicyRuleCondition policyRuleCondition =
new PolicyRuleCondition(
"kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue);
PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value");
PolicyRuleAction policyRuleAction =
new PolicyRuleAction(
PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION,
Arrays.asList(policyRuleActionConfig));
policyRuleBasic =
new PolicyRuleBasic(
policyId,
new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
1,
Arrays.asList(policyRuleCondition),
BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
Arrays.asList(policyRuleAction));
ServiceId serviceId = new ServiceId("contextId", "serviceId");
Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0);
List<String> deviceIds = Arrays.asList("device1", "device2");
policyRuleService = new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
}
@Test
void contextOrServiceIdMustNotBeEmpty()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
ServiceId serviceId = new ServiceId("", "");
List<String> deviceIds = Arrays.asList("device1", "device2");
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_FAILED, "Context Id of Service Id must not be empty.");
policyService
.updatePolicyService(policyRuleService)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void serviceIdMustNotBeEmpty() throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
ServiceId serviceId = new ServiceId("sdf", "");
List<String> deviceIds = Arrays.asList("device1", "device2");
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
PolicyRuleState expectedResult =
new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Service Id must not be empty.");
policyService
.updatePolicyService(policyRuleService)
.subscribe()
.with(item -> message.complete(item));
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void checkMessageIfServiceIsNotValid()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
ServiceId serviceId = new ServiceId("contextId", "serviceId");
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>());
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_FAILED, String.format(INVALID_MESSAGE, serviceId));
Mockito.when(
policyRuleConditionValidator.isPolicyRuleServiceValid(
Mockito.anyString(), Mockito.any(ServiceId.class)))
.thenReturn(Uni.createFrom().item(Boolean.FALSE));
policyService
.updatePolicyService(policyRuleService)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
@Test
void successUpdatePolicyService()
throws ExecutionException, InterruptedException, TimeoutException {
CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
ServiceId serviceId = new ServiceId("contextId", "serviceId");
PolicyRuleService policyRuleService =
new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>());
PolicyRuleState expectedResult =
new PolicyRuleState(
PolicyRuleStateEnum.POLICY_VALIDATED,
VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage());
Mockito.when(
policyRuleConditionValidator.isPolicyRuleServiceValid(
Mockito.anyString(), Mockito.any(ServiceId.class)))
.thenReturn(Uni.createFrom().item(Boolean.TRUE));
policyService
.updatePolicyService(policyRuleService)
.subscribe()
.with(
item -> {
message.complete(item);
});
assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
.isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
}
}
src/policy/target/kubernetes/kubernetes.yml
View file @ 6963de19
......@@ -3,8 +3,8 @@ apiVersion: v1
kind: Service
metadata:
annotations:
app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467
app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000
app.quarkus.io/commit-id: 47e6691312515be37e2d9ffa85a1ee165a66c9db
app.quarkus.io/build-timestamp: 2024-02-09 - 14:52:23 +0000
prometheus.io/scrape: "true"
prometheus.io/path: /q/metrics
prometheus.io/port: "8080"
......@@ -29,8 +29,8 @@ apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467
app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000
app.quarkus.io/commit-id: 47e6691312515be37e2d9ffa85a1ee165a66c9db
app.quarkus.io/build-timestamp: 2024-02-09 - 14:52:23 +0000
prometheus.io/scrape: "true"
prometheus.io/path: /q/metrics
prometheus.io/port: "8080"
......@@ -47,8 +47,8 @@ spec:
template:
metadata:
annotations:
app.quarkus.io/commit-id: 5f8866be9cb91871607627819258b0b375410467
app.quarkus.io/build-timestamp: 2024-01-26 - 16:40:15 +0000
app.quarkus.io/commit-id: 47e6691312515be37e2d9ffa85a1ee165a66c9db
app.quarkus.io/build-timestamp: 2024-02-09 - 14:52:23 +0000
prometheus.io/scrape: "true"
prometheus.io/path: /q/metrics
prometheus.io/port: "8080"
......@@ -63,12 +63,12 @@ spec:
valueFrom:
fieldRef:
fieldPath: metadata.namespace
- name: CONTEXT_SERVICE_HOST
value: contextservice
- name: SERVICE_SERVICE_HOST
value: serviceservice
- name: MONITORING_SERVICE_HOST
value: monitoringservice
- name: CONTEXT_SERVICE_HOST
value: contextservice
image: labs.etsi.org:5050/tfs/controller/policy:0.1.0
imagePullPolicy: Always
livenessProbe:
......
src/service/requirements.in
View file @ 6963de19
......@@ -19,3 +19,4 @@ netaddr==0.9.0
networkx==2.6.3
pydot==1.4.2
redis==4.1.2
requests==2.31.0
src/service/service/ServiceServiceServicerImpl.py
View file @ 6963de19
......@@ -34,6 +34,13 @@ from .service_handler_api.ServiceHandlerFactory import ServiceHandlerFactory
from .task_scheduler.TaskScheduler import TasksScheduler
from .tools.GeodesicDistance import gps_distance
from common.tools.object_factory.Context import json_context_id
from common.tools.object_factory.Topology import json_topology_id
from common.Constants import DEFAULT_CONTEXT_NAME, DEFAULT_TOPOLOGY_NAME
from common.proto.context_pb2 import Empty, TopologyId
from service.service.tools.OpticalTools import add_lightpath, delete_lightpath, adapt_reply, get_device_name_from_uuid, get_optical_band
LOGGER = logging.getLogger(__name__)
METRICS_POOL = MetricsPool('Service', 'RPC')
......@@ -241,7 +248,65 @@ class ServiceServiceServicerImpl(ServiceServiceServicer):
if len(service_with_uuids.service_endpoint_ids) >= num_expected_endpoints:
pathcomp_request = PathCompRequest()
pathcomp_request.services.append(service_with_uuids) # pylint: disable=no-member
if service.service_type == ServiceTypeEnum.SERVICETYPE_OPTICAL_CONNECTIVITY:
context_id_x = json_context_id(DEFAULT_CONTEXT_NAME)
topology_id_x = json_topology_id(
DEFAULT_TOPOLOGY_NAME, context_id_x)
topology_details = context_client.GetTopologyDetails(
TopologyId(**topology_id_x))
# devices = get_devices_in_topology(context_client, TopologyId(**topology_id_x), ContextId(**context_id_x))
devices = topology_details.devices
context_uuid_x = topology_details.topology_id.context_id.context_uuid.uuid
topology_uuid_x = topology_details.topology_id.topology_uuid.uuid
devs = []
ports = []
for endpoint_id in service.service_endpoint_ids:
devs.append(endpoint_id.device_id.device_uuid.uuid)
ports.append(endpoint_id.endpoint_uuid.uuid)
src = devs[0]
dst = devs[1]
bidir = None
ob_band = None
bitrate = 100
for constraint in service.service_constraints:
if "bandwidth" in constraint.custom.constraint_type:
bitrate = int(float(constraint.custom.constraint_value))
elif "bidirectionality" in constraint.custom.constraint_type:
bidir = int(constraint.custom.constraint_value)
elif "optical-band-width" in constraint.custom.constraint_type:
ob_band = int(constraint.custom.constraint_value)
# to get the reply form the optical module
reply_txt = add_lightpath(src, dst, bitrate, bidir, ob_band)
# reply with 2 transponders and 2 roadms
reply_json = json.loads(reply_txt)
optical_band_txt = ""
if "new_optical_band" in reply_json.keys():
if reply_json["new_optical_band"] == 1:
if reply_json["parent_opt_band"]:
if "parent_opt_band" in reply_json.keys():
parent_ob = reply_json["parent_opt_band"]
LOGGER.debug('Parent optical-band={}'.format(parent_ob))
optical_band_txt = get_optical_band(parent_ob)
LOGGER.debug('optical-band details={}'.format(optical_band_txt))
else:
LOGGER.debug('expected optical band not found')
else:
LOGGER.debug('expected optical band not found')
else:
LOGGER.debug('Using existing optical band')
else:
LOGGER.debug('Using existing optical band')
if reply_txt is not None:
optical_reply = adapt_reply(devices, _service, reply_json, context_uuid_x, topology_uuid_x, optical_band_txt)
LOGGER.debug('optical_reply={:s}'.format(
grpc_message_to_json_string(optical_reply)))
tasks_scheduler.compose_from_pathcompreply(
optical_reply, is_delete=False)
if num_disjoint_paths is None or num_disjoint_paths in {0, 1}:
pathcomp_request.shortest_path.Clear() # pylint: disable=no-member
else:
......@@ -280,6 +345,30 @@ class ServiceServiceServicerImpl(ServiceServiceServicer):
context_client.RemoveService(request)
return Empty()
if service.service_type == ServiceTypeEnum.SERVICETYPE_OPTICAL_CONNECTIVITY:
devs = []
context_id_x = json_context_id(DEFAULT_CONTEXT_NAME)
topology_id_x = json_topology_id(
DEFAULT_TOPOLOGY_NAME, context_id_x)
topology_details = context_client.GetTopologyDetails(
TopologyId(**topology_id_x))
devices = topology_details.devices
for endpoint_id in service.service_endpoint_ids:
devs.append(endpoint_id.device_id.device_uuid.uuid)
src = get_device_name_from_uuid(devices, devs[0])
dst = get_device_name_from_uuid(devices, devs[1])
bitrate = int(
float(service.service_constraints[0].custom.constraint_value))
if len(service.service_config.config_rules) > 0:
c_rules_dict = json.loads(
service.service_config.config_rules[0].custom.resource_value)
flow_id = c_rules_dict["flow_id"]
reply = delete_lightpath(flow_id, src, dst, bitrate)
# Normal service
# Feed TaskScheduler with this service and the sub-services and sub-connections related to this service.
# TaskScheduler identifies inter-dependencies among them and produces a schedule of tasks (an ordered list of
......
src/service/service/service_handlers/__init__.py
View file @ 6963de19
......@@ -26,6 +26,7 @@ from .p4.p4_service_handler import P4ServiceHandler
from .tapi_tapi.TapiServiceHandler import TapiServiceHandler
from .tapi_xr.TapiXrServiceHandler import TapiXrServiceHandler
from .e2e_orch.E2EOrchestratorServiceHandler import E2EOrchestratorServiceHandler
from .oc.OCServiceHandler import OCServiceHandler
SERVICE_HANDLERS = [
(L2NMEmulatedServiceHandler, [
......@@ -100,4 +101,10 @@ SERVICE_HANDLERS = [
FilterFieldEnum.DEVICE_DRIVER : [DeviceDriverEnum.DEVICEDRIVER_FLEXSCALE],
}
]),
(OCServiceHandler, [
{
FilterFieldEnum.SERVICE_TYPE : ServiceTypeEnum.SERVICETYPE_OPTICAL_CONNECTIVITY,
FilterFieldEnum.DEVICE_DRIVER : DeviceDriverEnum.DEVICEDRIVER_OC,
}
])
]
src/service/service/service_handlers/oc/ConfigRules.py 0 → 100644
View file @ 6963de19
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import Dict, List
from common.tools.object_factory.ConfigRule import json_config_rule_delete, json_config_rule_set
from service.service.service_handler_api.AnyTreeTools import TreeNode
def setup_config_rules(
service_uuid : str, connection_uuid : str, device_uuid : str, endpoint_uuid : str, endpoint_name : str,
service_settings : TreeNode, endpoint_settings : TreeNode
) -> List[Dict]:
if service_settings is None: return []
if endpoint_settings is None: return []
json_settings : Dict = service_settings.value
json_endpoint_settings : Dict = endpoint_settings.value
service_short_uuid = service_uuid.split('-')[-1]
network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
network_interface_desc = '{:s}-NetIf'.format(service_uuid)
network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)
mtu = json_settings.get('mtu', 1450 ) # 1512
#address_families = json_settings.get('address_families', [] ) # ['IPV4']
bgp_as = json_settings.get('bgp_as', 0 ) # 65000
bgp_route_target = json_settings.get('bgp_route_target', '0:0') # 65000:333
#router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0' ) # '60001:801'
sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30
if_subif_name = '{:s}.{:d}'.format(endpoint_name, vlan_id)
json_config_rules = [
json_config_rule_set(
'/network_instance[{:s}]'.format(network_instance_name), {
'name': network_instance_name, 'description': network_interface_desc, 'type': 'L3VRF',
'route_distinguisher': route_distinguisher,
#'router_id': router_id, 'address_families': address_families,
}),
json_config_rule_set(
'/interface[{:s}]'.format(endpoint_name), {
'name': endpoint_name, 'description': network_interface_desc, 'mtu': mtu,
}),
json_config_rule_set(
'/interface[{:s}]/subinterface[{:d}]'.format(endpoint_name, sub_interface_index), {
'name': endpoint_name, 'index': sub_interface_index,
'description': network_subinterface_desc, 'vlan_id': vlan_id,
'address_ip': address_ip, 'address_prefix': address_prefix,
}),
json_config_rule_set(
'/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
'name': network_instance_name, 'id': if_subif_name, 'interface': endpoint_name,
'subinterface': sub_interface_index,
}),
json_config_rule_set(
'/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP', 'as': bgp_as,
}),
json_config_rule_set(
'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',
'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
}),
json_config_rule_set(
'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
network_instance_name), {
'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',
'address_family': 'IPV4', #'default_import_policy': 'REJECT_ROUTE',
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
'policy_name': '{:s}_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
}),
json_config_rule_set(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name, 'import_policy': '{:s}_import'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
'policy_name': '{:s}_export'.format(network_instance_name),
}),
json_config_rule_set(
'/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
'match_set_options': 'ANY', 'policy_result': 'ACCEPT_ROUTE',
}),
json_config_rule_set(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name, 'export_policy': '{:s}_export'.format(network_instance_name),
}),
]
return json_config_rules
def teardown_config_rules(
service_uuid : str, connection_uuid : str, device_uuid : str, endpoint_uuid : str, endpoint_name : str,
service_settings : TreeNode, endpoint_settings : TreeNode
) -> List[Dict]:
if service_settings is None: return []
if endpoint_settings is None: return []
json_settings : Dict = service_settings.value
json_endpoint_settings : Dict = endpoint_settings.value
#mtu = json_settings.get('mtu', 1450 ) # 1512
#address_families = json_settings.get('address_families', [] ) # ['IPV4']
#bgp_as = json_settings.get('bgp_as', 0 ) # 65000
bgp_route_target = json_settings.get('bgp_route_target', '0:0') # 65000:333
#router_id = json_endpoint_settings.get('router_id', '0.0.0.0') # '10.95.0.10'
#route_distinguisher = json_endpoint_settings.get('route_distinguisher', '0:0' ) # '60001:801'
sub_interface_index = json_endpoint_settings.get('sub_interface_index', 0 ) # 1
vlan_id = json_endpoint_settings.get('vlan_id', 1 ) # 400
#address_ip = json_endpoint_settings.get('address_ip', '0.0.0.0') # '2.2.2.1'
#address_prefix = json_endpoint_settings.get('address_prefix', 24 ) # 30
if_subif_name = '{:s}.{:d}'.format(endpoint_name, vlan_id)
service_short_uuid = service_uuid.split('-')[-1]
network_instance_name = '{:s}-NetInst'.format(service_short_uuid)
#network_interface_desc = '{:s}-NetIf'.format(service_uuid)
#network_subinterface_desc = '{:s}-NetSubIf'.format(service_uuid)
json_config_rules = [
json_config_rule_delete(
'/network_instance[{:s}]/interface[{:s}]'.format(network_instance_name, if_subif_name), {
'name': network_instance_name, 'id': if_subif_name,
}),
json_config_rule_delete(
'/interface[{:s}]/subinterface[{:d}]'.format(endpoint_name, sub_interface_index), {
'name': endpoint_name, 'index': sub_interface_index,
}),
json_config_rule_delete(
'/interface[{:s}]'.format(endpoint_name), {
'name': endpoint_name,
}),
json_config_rule_delete(
'/network_instance[{:s}]/table_connections[DIRECTLY_CONNECTED][BGP][IPV4]'.format(
network_instance_name), {
'name': network_instance_name, 'src_protocol': 'DIRECTLY_CONNECTED', 'dst_protocol': 'BGP',
'address_family': 'IPV4',
}),
json_config_rule_delete(
'/network_instance[{:s}]/table_connections[STATIC][BGP][IPV4]'.format(network_instance_name), {
'name': network_instance_name, 'src_protocol': 'STATIC', 'dst_protocol': 'BGP',
'address_family': 'IPV4',
}),
json_config_rule_delete(
'/network_instance[{:s}]/protocols[BGP]'.format(network_instance_name), {
'name': network_instance_name, 'identifier': 'BGP', 'protocol_name': 'BGP',
}),
json_config_rule_delete(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_import]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name,
}),
json_config_rule_delete(
'/routing_policy/policy_definition[{:s}_import]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_import'.format(network_instance_name), 'statement_name': '3',
}),
json_config_rule_delete(
'/routing_policy/policy_definition[{:s}_import]'.format(network_instance_name), {
'policy_name': '{:s}_import'.format(network_instance_name),
}),
json_config_rule_delete(
'/routing_policy/bgp_defined_set[{:s}_rt_import][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_delete(
'/routing_policy/bgp_defined_set[{:s}_rt_import]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_import'.format(network_instance_name),
}),
json_config_rule_delete(
# pylint: disable=duplicate-string-formatting-argument
'/network_instance[{:s}]/inter_instance_policies[{:s}_export]'.format(
network_instance_name, network_instance_name), {
'name': network_instance_name,
}),
json_config_rule_delete(
'/routing_policy/policy_definition[{:s}_export]/statement[{:s}]'.format(
network_instance_name, '3'), {
'policy_name': '{:s}_export'.format(network_instance_name), 'statement_name': '3',
}),
json_config_rule_delete(
'/routing_policy/policy_definition[{:s}_export]'.format(network_instance_name), {
'policy_name': '{:s}_export'.format(network_instance_name),
}),
json_config_rule_delete(
'/routing_policy/bgp_defined_set[{:s}_rt_export][route-target:{:s}]'.format(
network_instance_name, bgp_route_target), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
'ext_community_member' : 'route-target:{:s}'.format(bgp_route_target),
}),
json_config_rule_delete(
'/routing_policy/bgp_defined_set[{:s}_rt_export]'.format(network_instance_name), {
'ext_community_set_name': '{:s}_rt_export'.format(network_instance_name),
}),
json_config_rule_delete(
'/network_instance[{:s}]'.format(network_instance_name), {
'name': network_instance_name
}),
]
return json_config_rules
src/service/service/service_handlers/oc/OCServiceHandler.py 0 → 100644
View file @ 6963de19
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json, logging
from typing import Any, List, Optional, Tuple, Union
from common.method_wrappers.Decorator import MetricsPool, metered_subclass_method
from common.proto.context_pb2 import ConfigRule, DeviceId, Service
from common.tools.object_factory.Device import json_device_id
from common.type_checkers.Checkers import chk_type
from service.service.service_handler_api.Tools import get_device_endpoint_uuids, get_endpoint_matching
from service.service.service_handler_api._ServiceHandler import _ServiceHandler
from service.service.service_handler_api.SettingsHandler import SettingsHandler
from service.service.task_scheduler.TaskExecutor import TaskExecutor
from .ConfigRules import setup_config_rules, teardown_config_rules
from common.proto.context_pb2 import EndPointId
from .OCTools import convert_endpoints_to_flows, handle_flows_names
LOGGER = logging.getLogger(__name__)
METRICS_POOL = MetricsPool('Service', 'Handler', labels={'handler': 'l3nm_emulated'})
class OCServiceHandler(_ServiceHandler):
def __init__( # pylint: disable=super-init-not-called
self, service : Service, task_executor : TaskExecutor, **settings
) -> None:
self.__service = service
self.__task_executor = task_executor
self.__settings_handler = SettingsHandler(service.service_config, **settings)
'''
@metered_subclass_method(METRICS_POOL)
def SetEndpoint(
self, endpoints : List[Tuple[str, str, Optional[str]]], connection_uuid : Optional[str] = None
) -> List[Union[bool, Exception]]:
chk_type('endpoints', endpoints, list)
if len(endpoints) == 0: return []
service_uuid = self.__service.service_id.service_uuid.uuid
if self.__settings_handler.get('/settings-ob_{}'.format(connection_uuid)):
settings = self.__settings_handler.get('/settings-ob_{}'.format(connection_uuid))
else:
settings = self.__settings_handler.get('/settings')
LOGGER.info("AAAAAAAAAAAAAAAAAAAA settings={}".format(settings))
settings = self.__settings_handler.get('/settings')
#new structure
#in, dev, out, topo(opt)
entries = List[Tuple[str, str, str Optional[str]]]
entry_tuple = device_uuid, endpoint_uuid, topology_uuid
entries.append(endpoint_id_tuple)
for i in range (1, len(endpoints)):
endpoint_x = endpoints[i]
dev_x = endpoint_x[0]
if_x = endpoint_x[1]
results = []
for endpoint in endpoints:
try:
device_uuid, endpoint_uuid = get_device_endpoint_uuids(endpoint)
device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
endpoint_obj = get_endpoint_matching(device_obj, endpoint_uuid)
endpoint_settings = self.__settings_handler.get_endpoint_settings(device_obj, endpoint_obj)
endpoint_name = endpoint_obj.name
json_config_rules = setup_config_rules(
service_uuid, connection_uuid, device_uuid, endpoint_uuid, endpoint_name,
settings, endpoint_settings)
LOGGER.info("Start configuring device %s",settings)
if (settings):
self.__task_executor.configure_optical_device(device_obj,settings)
if len(json_config_rules) > 0:
LOGGER.info("Start configuring device")
del device_obj.device_config.config_rules[:]
for json_config_rule in json_config_rules:
device_obj.device_config.config_rules.append(ConfigRule(**json_config_rule))
self.__task_executor.configure_optical_device(device_obj)
#self.__task_executor.configure_device(device_obj)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to SetEndpoint({:s})'.format(str(endpoint)))
results.append(e)
return results
'''
@metered_subclass_method(METRICS_POOL)
def SetEndpoint(
self, endpoints : List[Tuple[str, str, Optional[str]]], connection_uuid : Optional[str] = None
) -> List[Union[bool, Exception]]:
chk_type('endpoints', endpoints, list)
if len(endpoints) == 0: return []
is_opticalband =False
#service_uuid = self.__service.service_id.service_uuid.uuid
settings=None
if self.__settings_handler.get('/settings-ob_{}'.format(connection_uuid)):
is_opticalband=True
settings = self.__settings_handler.get('/settings-ob_{}'.format(connection_uuid))
else:
settings = self.__settings_handler.get('/settings')
LOGGER.debug("Andrea111 settings={}".format(settings))
# settings = self.__settings_handler.get('/settings')
#flow is the new variable that stores input-output relationship
flows = convert_endpoints_to_flows(endpoints)
#handled_flows=handle_flows_names(flows=flows,task_executor=self.__task_executor)
LOGGER.debug("AndreaXXX dict of flows= {}".format(flows))
#LOGGER.info("Handled Flows %s",handled_flows)
results = []
#new cycle for setting optical devices
for device_uuid in flows.keys():
try:
dev_flows = flows[device_uuid]
device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
LOGGER.debug("Andrea567 device_obj={}".format(device_obj))
'''
#to be imported in the device handler
endpoint_obj = get_endpoint_matching(device_obj, endpoint_uuid)
endpoint_settings = self.__settings_handler.get_endpoint_settings(device_obj, endpoint_obj)
endpoint_name = endpoint_obj.name
'''
if (settings):
LOGGER.debug("Andrea234 settings={}".format(settings))
self.__task_executor.configure_optical_device(device_obj, settings, dev_flows, is_opticalband)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to configure Device({:s})'.format(str(device_uuid)))
results.append(e)
'''
for endpoint in endpoints:
try:
device_uuid, endpoint_uuid = get_device_endpoint_uuids(endpoint)
device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
endpoint_obj = get_endpoint_matching(device_obj, endpoint_uuid)
endpoint_settings = self.__settings_handler.get_endpoint_settings(device_obj, endpoint_obj)
endpoint_name = endpoint_obj.name
# json_config_rules = setup_config_rules(
# service_uuid, connection_uuid, device_uuid, endpoint_uuid, endpoint_name,
# settings, endpoint_settings)
if (settings):
LOGGER.debug("Andrea234 settings={}".format(settings))
self.__task_executor.configure_optical_device(device_obj,settings,handled_flows,is_opticalband)
#we don't use config_rules
# if len(json_config_rules) > 0:
# LOGGER.debug("VBNMHGStart configuring device")
# del device_obj.device_config.config_rules[:]
# for json_config_rule in json_config_rules:
# device_obj.device_config.config_rules.append(ConfigRule(**json_config_rule))
# self.__task_executor.configure_optical_device(device_obj)
#self.__task_executor.configure_device(device_obj)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to SetEndpoint({:s})'.format(str(endpoint)))
results.append(e)
'''
return results
@metered_subclass_method(METRICS_POOL)
def DeleteEndpoint(
self, endpoints : List[Tuple[str, str, Optional[str]]], connection_uuid : Optional[str] = None
) -> List[Union[bool, Exception]]:
chk_type('endpoints', endpoints, list)
if len(endpoints) == 0: return []
service_uuid = self.__service.service_id.service_uuid.uuid
settings = self.__settings_handler.get('/settings')
results = []
for endpoint in endpoints:
try:
device_uuid, endpoint_uuid = get_device_endpoint_uuids(endpoint)
device_obj = self.__task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
endpoint_obj = get_endpoint_matching(device_obj, endpoint_uuid)
endpoint_settings = self.__settings_handler.get_endpoint_settings(device_obj, endpoint_obj)
endpoint_name = endpoint_obj.name
json_config_rules = teardown_config_rules(
service_uuid, connection_uuid, device_uuid, endpoint_uuid, endpoint_name,
settings, endpoint_settings)
if len(json_config_rules) > 0:
del device_obj.device_config.config_rules[:]
for json_config_rule in json_config_rules:
device_obj.device_config.config_rules.append(ConfigRule(**json_config_rule))
self.__task_executor.configure_device(device_obj)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to DeleteEndpoint({:s})'.format(str(endpoint)))
results.append(e)
return results
@metered_subclass_method(METRICS_POOL)
def SetConstraint(self, constraints : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
chk_type('constraints', constraints, list)
if len(constraints) == 0: return []
msg = '[SetConstraint] Method not implemented. Constraints({:s}) are being ignored.'
LOGGER.warning(msg.format(str(constraints)))
return [True for _ in range(len(constraints))]
@metered_subclass_method(METRICS_POOL)
def DeleteConstraint(self, constraints : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
chk_type('constraints', constraints, list)
if len(constraints) == 0: return []
msg = '[DeleteConstraint] Method not implemented. Constraints({:s}) are being ignored.'
LOGGER.warning(msg.format(str(constraints)))
return [True for _ in range(len(constraints))]
@metered_subclass_method(METRICS_POOL)
def SetConfig(self, resources : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
chk_type('resources', resources, list)
if len(resources) == 0: return []
results = []
for resource in resources:
try:
resource_value = json.loads(resource[1])
self.__settings_handler.set(resource[0], resource_value)
results.append(True)
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to SetConfig({:s})'.format(str(resource)))
results.append(e)
return results
@metered_subclass_method(METRICS_POOL)
def DeleteConfig(self, resources : List[Tuple[str, Any]]) -> List[Union[bool, Exception]]:
chk_type('resources', resources, list)
if len(resources) == 0: return []
results = []
for resource in resources:
try:
self.__settings_handler.delete(resource[0])
except Exception as e: # pylint: disable=broad-except
LOGGER.exception('Unable to DeleteConfig({:s})'.format(str(resource)))
results.append(e)
return results
src/service/service/service_handlers/oc/OCTools.py 0 → 100644
View file @ 6963de19
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from service.service.service_handler_api.Tools import get_device_endpoint_uuids, get_endpoint_matching
from typing import Dict, Any, List, Optional, Tuple
import logging
from common.proto.context_pb2 import ConfigRule, DeviceId, Service
from common.tools.object_factory.Device import json_device_id
log = logging.getLogger(__name__)
#def convert_endpoints_to_flows(endpoints : List[Tuple[str, str, Optional[str]]])->Dict[str: List[Tuple[str, str]]]:
def convert_endpoints_to_flows(endpoints : List[Tuple[str, str, Optional[str]]])->Dict:
#entries = List[Tuple[str, str, str, Optional[str]]]
#entries = Dict[str: List[Tuple[str, str]]]
entries = {}
#tuple is in, out
end = len(endpoints)
i = 0
bidir = 0
log.debug("end={}".format(end))
while(i < end):
endpoint = endpoints[i]
device_uuid, endpoint_uuid = endpoint[0:2]
log.debug("current OCTools step {}, {}, {}".format(i, device_uuid, endpoint_uuid))
if device_uuid not in entries.keys():
entries[device_uuid] = []
if i == 0:
entry_tuple = "0", endpoint_uuid
entries[device_uuid].append(entry_tuple)
next_endpoint = endpoints[i+1]
next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
if next_device_uuid == device_uuid:
bidir = 1
log.debug("connection is bidirectional")
entry_tuple = next_endpoint_uuid, "0"
entries[device_uuid].append(entry_tuple)
i = i + 1
else:
log.debug("connection is unidirectional")
else:
if not bidir:
if i == end-1:
#is the last node
entry_tuple = endpoint_uuid, "0"
entries[device_uuid].append(entry_tuple)
else:
#it is a transit node
next_endpoint = endpoints[i+1]
next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
if next_device_uuid == device_uuid:
entry_tuple = endpoint_uuid, next_endpoint_uuid
entries[device_uuid].append(entry_tuple)
i = i + 1
log.debug("current OCTools step {}, {}, {}".format(i, next_device_uuid, device_uuid))
else:
log.debug("ERROR in unidirectional connection 4")
return {}
if bidir:
log.debug("Ocheck i {}, {}, {}".format(i, i+1, end-1))
if i + 1 == end-1:
log.debug("current OCTools step {}, {}, {}".format(i, device_uuid, endpoint_uuid))
#is the last node
entry_tuple = endpoint_uuid, "0"
entries[device_uuid].append(entry_tuple)
next_endpoint = endpoints[i+1]
log.debug("OCTools i+1 step {}, {}, {}".format(i+1, next_device_uuid, device_uuid))
next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
if next_device_uuid == device_uuid:
entry_tuple = "0", next_endpoint_uuid
entries[device_uuid].append(entry_tuple)
i = i + 1
else:
log.debug("ERROR in bidirectional connection 2")
return entries
else:
log.debug("OCTools i+1+2+3 step {}, {}, {}".format(i+1, next_device_uuid, device_uuid))
#i+1
next_endpoint = endpoints[i+1]
next_device_uuid, next_endpoint_uuid = next_endpoint[0:2]
if next_device_uuid == device_uuid:
entry_tuple = endpoint_uuid, next_endpoint_uuid
entries[device_uuid].append(entry_tuple)
else:
log.debug("ERROR in bidirectional connection 3")
log.debug("{}, {}, {}".format(i, next_device_uuid, device_uuid))
return entries
#i+2
next_2_endpoint = endpoints[i+2]
next_2_device_uuid, next_2_endpoint_uuid = next_2_endpoint[0:2]
#i+3
next_3_endpoint = endpoints[i+3]
next_3_device_uuid, next_3_endpoint_uuid = next_3_endpoint[0:2]
if next_2_device_uuid == next_3_device_uuid and next_3_device_uuid == device_uuid:
entry_tuple = next_2_endpoint_uuid, next_3_endpoint_uuid
entries[device_uuid].append(entry_tuple)
i = i + 3
else:
log.debug("ERROR in bidirection connection 4")
return {}
i = i + 1
return entries
def get_device_endpint_name (endpoint_uuid:str,device_uuid:str,task_executor)->Tuple:
device_obj = task_executor.get_device(DeviceId(**json_device_id(device_uuid)))
endpoint_obj = get_endpoint_matching(device_obj, endpoint_uuid)
endpoint_name = endpoint_obj.name
return (device_obj.name,endpoint_name)
def handle_flows_names (task_executor,flows:dict)->Dict :
new_flows={}
for index,( device_uuid_key , device_endpoints_list) in enumerate(flows.items()):
for endpoint_tupple in device_endpoints_list:
source_port=None
destination_port=None
device_name=""
source_endpoint,destination_endpoint =endpoint_tupple
if (source_endpoint !='0'):
if get_device_endpint_name(source_endpoint,device_uuid_key,task_executor) is not None:
device_name,source_port=get_device_endpint_name(source_endpoint,device_uuid_key,task_executor)
if (destination_endpoint !='0'):
if get_device_endpint_name(destination_endpoint,device_uuid_key,task_executor) is not None:
device_name,destination_port=get_device_endpint_name(destination_endpoint,device_uuid_key,task_executor)
if (device_name not in new_flows):
new_flows[device_name]=[]
new_flows[device_name].append((source_port,destination_port))
return new_flows
\ No newline at end of file
src/service/service/service_handlers/oc/__init__.py 0 → 100644
View file @ 6963de19
# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
src/service/service/task_scheduler/TaskExecutor.py
View file @ 6963de19
......@@ -16,7 +16,7 @@ import logging #, json
from enum import Enum
from typing import TYPE_CHECKING, Any, Dict, Optional, Union
from common.method_wrappers.ServiceExceptions import NotFoundException
from common.proto.context_pb2 import Connection, ConnectionId, Device, DeviceDriverEnum, DeviceId, Service, ServiceId
from common.proto.context_pb2 import Connection, ConnectionId, Device, DeviceDriverEnum, DeviceId, Service, ServiceId,MyConfig,MyConfigId
from common.tools.context_queries.Connection import get_connection_by_id
from common.tools.context_queries.Device import get_device
from common.tools.context_queries.Service import get_service_by_id
......@@ -108,10 +108,74 @@ class TaskExecutor:
return device
def configure_device(self, device : Device) -> None:
self._context_client.SelectMyConfig()
device_key = get_device_key(device.device_id)
self._device_client.ConfigureDevice(device)
self._store_grpc_object(CacheableObjectType.DEVICE, device_key, device)
# New function Andrea for Optical Devices
def configure_optical_device(self,device:Device,settings:str,flows:list,is_opticalband:bool):
device_key = get_device_key(device.device_id)
myid=MyConfigId()
myid.myconfig_uuid=device.device_id.device_uuid.uuid
myConfig=MyConfig()
setting =settings.value if settings else ""
new_config={}
try:
result=self._context_client.SelectMyConfig(myid)
new_config=eval(result.config)
LOGGER.info("result %s",result)
if result is not None :
new_config["new_config"]=setting
new_config["is_opticalband"]=is_opticalband
new_config["flow"]=flows
result.config = str(new_config)
myConfig.CopyFrom(result)
self._device_client.ConfigureOpticalDevice(myConfig)
self._store_grpc_object(CacheableObjectType.DEVICE, device_key, device)
except Exception as e:
LOGGER.debug("error in config my config %s",e)
'''
# For Optical Devices
def configure_optical_device (self,device:Device,settings:str,flows:dict,is_opticalband:bool) :
device_key = get_device_key(device.device_id)
myid=MyConfigId()
myid.myconfig_uuid=device.device_id.device_uuid.uuid
myConfig=MyConfig()
setting =settings.value if settings else ""
new_config={}
try:
result=self._context_client.SelectMyConfig(myid)
new_config=eval(result.config)
if result is not None :
new_config["new_config"]=setting
new_config["is_opticalband"]=is_opticalband
new_config["flow"]=flows
result.config = str(new_config)
myConfig.CopyFrom(result)
self._device_client.ConfigureOpticalDevice(myConfig)
self._store_grpc_object(CacheableObjectType.DEVICE, device_key, device)
except Exception as e:
LOGGER.debug("error in config my config %s",e)
'''
def get_device_controller(self, device : Device) -> Optional[Device]:
#json_controller = None
#for config_rule in device.device_config.config_rules:
......