Initial code check-in for A1 Policy Enforcement Simulator

Issue-ID: INT-1887
Signed-off-by: Krystian Kedron <k.kedron@partner.samsung.com>
Change-Id: I643dadac5386bf21eaa108435c83b69706b0bc1c

76 files changed, 4418 insertions, 0 deletions

diff --git a/src/main/java/org/onap/a1pesimulator/A1PolicyEnforcementSimulatorApplication.java b/src/main/java/org/onap/a1pesimulator/A1PolicyEnforcementSimulatorApplication.java
new file mode 100644
index 0000000..fad5083
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/A1PolicyEnforcementSimulatorApplication.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class A1PolicyEnforcementSimulatorApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(A1PolicyEnforcementSimulatorApplication.class, args);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/configuration/SwaggerConfig.java b/src/main/java/org/onap/a1pesimulator/configuration/SwaggerConfig.java
new file mode 100644
index 0000000..f534153
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/configuration/SwaggerConfig.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.configuration;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.ApiInfoBuilder;
+import springfox.documentation.builders.PathSelectors;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.service.ApiInfo;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+@Configuration
+@EnableSwagger2
+public class SwaggerConfig {
+
+    @Bean
+    public Docket api() {
+        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
+                       .apis(RequestHandlerSelectors.basePackage("org.onap.a1pesimulator")).paths(PathSelectors.any())
+                       .build();
+    }
+
+    public ApiInfo apiInfo() {
+        final ApiInfoBuilder builder = new ApiInfoBuilder();
+        builder.title("A1 Policy Enforcement Simulator REST APIs")
+                .description("A1 Policy Enforcement Simulator REST interfaces (Policy Enforcement PoC)")
+                .version("1.0.0").license("Copyright (C) 2021 Samsung Electronics");
+        return builder.build();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/a1pesimulator/configuration/VesBrokerConfiguration.java b/src/main/java/org/onap/a1pesimulator/configuration/VesBrokerConfiguration.java
new file mode 100644
index 0000000..4003515
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/configuration/VesBrokerConfiguration.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.configuration;
+
+import java.security.KeyManagementException;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.X509Certificate;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
+import org.springframework.web.client.RestTemplate;
+
+@Configuration
+public class VesBrokerConfiguration {
+
+    @Bean
+    public RestTemplate restTemplate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
+        TrustManager[] trustAllCerts = new TrustManager[] {new X509TrustManager() {
+            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+                return new X509Certificate[0];
+            }
+
+            public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
+            }
+
+            public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
+            }
+        }};
+        SSLContext sslContext = SSLContext.getInstance("TLS");
+        sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
+        CloseableHttpClient httpClient =
+                HttpClients.custom().setSSLContext(sslContext).setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
+                        .build();
+        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
+
+        requestFactory.setHttpClient(httpClient);
+        return new RestTemplate(requestFactory);
+    }
+
+}
diff --git a/src/main/java/org/onap/a1pesimulator/configuration/VesPmThreadPoolTaskSchedulerConfig.java b/src/main/java/org/onap/a1pesimulator/configuration/VesPmThreadPoolTaskSchedulerConfig.java
new file mode 100644
index 0000000..9105544
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/configuration/VesPmThreadPoolTaskSchedulerConfig.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.configuration;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
+
+@Configuration
+public class VesPmThreadPoolTaskSchedulerConfig {
+
+    private Integer poolSize;
+
+    public VesPmThreadPoolTaskSchedulerConfig(@Value("${ves.pm.maxPoolSize}") Integer poolSize) {
+        this.poolSize = poolSize;
+    }
+
+    @Bean
+    public ThreadPoolTaskScheduler vesPmThreadPoolTaskScheduler() {
+        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
+        threadPoolTaskScheduler.setPoolSize(poolSize);
+        threadPoolTaskScheduler.setThreadNamePrefix("VesPmThreadPoolTaskScheduler");
+        return threadPoolTaskScheduler;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/configuration/WebConfig.java b/src/main/java/org/onap/a1pesimulator/configuration/WebConfig.java
new file mode 100644
index 0000000..166361e
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/configuration/WebConfig.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.configuration;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class WebConfig implements WebMvcConfigurer {
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**");
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/configuration/WebSocketConfig.java b/src/main/java/org/onap/a1pesimulator/configuration/WebSocketConfig.java
new file mode 100644
index 0000000..8cf24bc
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/configuration/WebSocketConfig.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.configuration;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
+import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
+import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
+
+@Configuration
+@EnableWebSocketMessageBroker
+public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
+
+    @Override
+    public void registerStompEndpoints(StompEndpointRegistry registry) {
+        registry.addEndpoint("/ws").setAllowedOrigins("*").withSockJS();
+    }
+
+    @Override
+    public void configureMessageBroker(MessageBrokerRegistry config) {
+        config.enableSimpleBroker("/topic", "/queue");
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/a1pesimulator/controller/RanA1Controller.java b/src/main/java/org/onap/a1pesimulator/controller/RanA1Controller.java
new file mode 100644
index 0000000..4262d27
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/controller/RanA1Controller.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.controller;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.Collection;
+import org.onap.a1pesimulator.data.PolicyNotification;
+import org.onap.a1pesimulator.data.PolicyNotificationActionEnum;
+import org.onap.a1pesimulator.service.a1.A1Service;
+import org.onap.a1pesimulator.service.a1.OnPolicyAction;
+import org.onap.a1pesimulator.service.a1.PolicyInstancesHolder;
+import org.springframework.http.ResponseEntity;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * A1 interface facade
+ * Only operations defined by OSC_2.1.0 should be provided here
+ */
+
+@RestController
+@RequestMapping({"${restapi.version}/a1-p"})
+public class RanA1Controller {
+
+    private static final String TOPIC_POLICY = "/topic/policy";
+    private final SimpMessagingTemplate messagingTemplate;
+    private final A1Service a1Service;
+    private final Collection<OnPolicyAction> onPolicyActions;
+    private final PolicyInstancesHolder policyHolder;
+
+    public RanA1Controller(A1Service a1Service, SimpMessagingTemplate messagingTemplate,
+            Collection<OnPolicyAction> onPolicyActions, PolicyInstancesHolder policyHolder) {
+        this.a1Service = a1Service;
+        this.messagingTemplate = messagingTemplate;
+        this.onPolicyActions = onPolicyActions;
+        this.policyHolder = policyHolder;
+    }
+
+    @GetMapping(value = "/healthcheck")
+    public ResponseEntity<String> healthcheck() throws URISyntaxException {
+        return a1Service.healthCheck();
+    }
+
+    @PutMapping(value = "/policytypes/{policyTypeId}")
+    public ResponseEntity<String> putPolicySchema(@PathVariable Integer policyTypeId, @RequestBody String body)
+            throws URISyntaxException {
+        return a1Service.putPolicySchema(policyTypeId, body);
+    }
+
+    @PutMapping(value = "/policytypes/{policyTypeId}/policies/{policyInstanceId}")
+    public ResponseEntity<String> putPolicyInstance(@PathVariable Integer policyTypeId,
+            @PathVariable String policyInstanceId, @RequestBody String body) throws URISyntaxException {
+        ResponseEntity<String> response = a1Service.putPolicy(policyTypeId, policyInstanceId, body);
+        if (!response.getStatusCode().is2xxSuccessful()) {
+            return response;
+        }
+        policyHolder.addPolicy(policyInstanceId, body);
+        onPolicyActions.forEach(action -> handleOnPolicyAction(policyTypeId, policyInstanceId, body, action));
+        messagingTemplate.convertAndSend(TOPIC_POLICY,
+                new PolicyNotification(policyInstanceId, policyTypeId, PolicyNotificationActionEnum.CREATED, body));
+        return response;
+    }
+
+    @DeleteMapping(value = "/policytypes/{policyTypeId}/policies/{policyInstanceId}")
+    public ResponseEntity<String> deletePolicyInstance(@PathVariable Integer policyTypeId,
+            @PathVariable String policyInstanceId) throws URISyntaxException {
+        ResponseEntity<String> response = a1Service.deletePolicy(policyTypeId, policyInstanceId);
+        if (!response.getStatusCode().is2xxSuccessful()) {
+            return response;
+        }
+
+        policyHolder.removePolicy(policyInstanceId);
+        messagingTemplate.convertAndSend(TOPIC_POLICY,
+                new PolicyNotification(policyInstanceId, policyTypeId, PolicyNotificationActionEnum.DELETED));
+        return response;
+    }
+
+    @GetMapping(value = "/policytypes")
+    public ResponseEntity<String> getPolicyTypeIds() throws URISyntaxException {
+        return a1Service.getPolicyTypeIds();
+    }
+
+    @GetMapping(value = "/policytypes/{policyTypeId}")
+    public ResponseEntity<String> getPolicyType(@PathVariable Integer policyTypeId) throws URISyntaxException {
+        return a1Service.getPolicyType(policyTypeId);
+    }
+
+    @GetMapping(value = "/policytypes/{policyTypeId}/policies")
+    public ResponseEntity<String> getPolicyIdsOfType(@PathVariable Integer policyTypeId)
+            throws URISyntaxException, IOException {
+        return a1Service.getPolicyIdsOfType(policyTypeId);
+    }
+
+    @GetMapping(value = "/policytypes/{policyTypeId}/policies/{policyInstanceId}")
+    public ResponseEntity<String> getPolicy(@PathVariable Integer policyTypeId, @PathVariable String policyInstanceId)
+            throws URISyntaxException {
+        return a1Service.getPolicy(policyTypeId, policyInstanceId);
+    }
+
+    private void handleOnPolicyAction(Integer policyTypeId, String policyId, String body, OnPolicyAction action) {
+        if (action.isForMe(policyTypeId, policyId, body)) {
+            action.onPolicy(policyTypeId, policyId, body);
+        }
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/controller/RanCellController.java b/src/main/java/org/onap/a1pesimulator/controller/RanCellController.java
new file mode 100644
index 0000000..d454116
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/controller/RanCellController.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.controller;
+
+import java.util.Optional;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.RanCell;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.RanPeriodicVesEvent;
+import org.onap.a1pesimulator.service.cell.RanCellService;
+import org.onap.a1pesimulator.service.cell.RanCellStateService;
+import org.onap.a1pesimulator.service.ves.RanVesBrokerService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping({"${restapi.version}/ran/cells"})
+public class RanCellController {
+
+    private static final Logger log = LoggerFactory.getLogger(RanCellController.class);
+    private final RanCellService ranCellService;
+    private final RanCellStateService ranCellStateService;
+    private final RanVesBrokerService ranVesBrokerService;
+
+    public RanCellController(RanCellService ranCellService, RanCellStateService ranCellStateService,
+            RanVesBrokerService ranVesBrokerService) {
+        this.ranCellService = ranCellService;
+        this.ranCellStateService = ranCellStateService;
+        this.ranVesBrokerService = ranVesBrokerService;
+    }
+
+    @GetMapping
+    public ResponseEntity<RanCell> getCells() {
+        return ResponseEntity.ok(ranCellService.getCells());
+    }
+
+    @GetMapping(value = "/{identifier}")
+    public ResponseEntity<CellDetails> getCellById(final @PathVariable String identifier) {
+
+        if (!ranCellService.getCellIds().contains(identifier)) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(ranCellService.getCellById(identifier));
+    }
+
+    @PostMapping(value = "/{identifier}/startFailure")
+    public ResponseEntity<String> startSendingFailureVesEvents(final @PathVariable String identifier) {
+
+        ranCellService.failure(identifier);
+        ranVesBrokerService.startSendingFailureVesEvents(identifier);
+        ranCellStateService.failingState(identifier);
+
+        return ResponseEntity.accepted().body("Failure VES Event sending started");
+    }
+
+    @PostMapping(value = "/{identifier}/stopFailure")
+    public ResponseEntity<Void> stopSendingFailureVesEvents(final @PathVariable String identifier) {
+
+        ranCellService.recoverFromFailure(identifier);
+
+        Optional<RanPeriodicVesEvent> vesEvent = ranVesBrokerService.stopSendingVesEvents(identifier);
+
+        if (!vesEvent.isPresent()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        ranCellStateService.stopState(identifier);
+        return ResponseEntity.accepted().build();
+    }
+
+    @PostMapping(value = "/{identifier}/start")
+    public ResponseEntity<String> startSendingVesEvents(final @RequestBody Optional<Event> vesEventOpt,
+            final @PathVariable String identifier, final @RequestParam(required = false) Integer interval) {
+        log.info("Start sending ves events every {} seconds for {} ", getInterval(interval), identifier);
+
+        Event vesEvent = vesEventOpt.orElse(ranVesBrokerService.getGlobalPmVesStructure());
+
+        ResponseEntity<String> responseEntity =
+                ranVesBrokerService.startSendingVesEvents(identifier, vesEvent, getInterval(interval));
+        if (!responseEntity.getStatusCode().is2xxSuccessful()) {
+            return responseEntity;
+        }
+
+        ranCellStateService.activateState(identifier);
+        return responseEntity;
+    }
+
+    @PostMapping(value = "/{identifier}/stop")
+    public ResponseEntity<Void> stopSendingVesEvents(final @PathVariable String identifier) {
+        log.info("Stop sending custom ves events for {}", identifier);
+        Optional<RanPeriodicVesEvent> vesEvent = ranVesBrokerService.stopSendingVesEvents(identifier);
+        if (!vesEvent.isPresent()) {
+            return ResponseEntity.notFound().build();
+        }
+
+        ranCellStateService.stopState(identifier);
+        return ResponseEntity.accepted().build();
+    }
+
+    @GetMapping(value = "/{identifier}/eventStructure")
+    public ResponseEntity<Event> getVesEventStructure(final @PathVariable String identifier) {
+        if (!ranVesBrokerService.getEnabledEventElementIdentifiers().contains(identifier)) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(ranVesBrokerService.getEventStructure(identifier));
+    }
+
+    private Integer getInterval(Integer requested) {
+        if (requested == null) {
+            return ranVesBrokerService.getGlobalVesInterval();
+        }
+        return requested;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/controller/RanController.java b/src/main/java/org/onap/a1pesimulator/controller/RanController.java
new file mode 100644
index 0000000..03ea4b8
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/controller/RanController.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.controller;
+
+import org.onap.a1pesimulator.data.Topology;
+import org.onap.a1pesimulator.service.cell.RanCellService;
+import org.onap.a1pesimulator.util.ItemsRefresher;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping({"${restapi.version}/ran"})
+public class RanController {
+
+    private static final Logger log = LoggerFactory.getLogger(RanController.class);
+    private final RanCellService ranCellService;
+    private final ItemsRefresher refresher;
+
+    public RanController(RanCellService ranCellService, final ItemsRefresher refresher) {
+        this.ranCellService = ranCellService;
+        this.refresher = refresher;
+    }
+
+    @GetMapping
+    public ResponseEntity<Topology> getRan() {
+        return ResponseEntity.ok(ranCellService.getTopology());
+    }
+
+    @GetMapping(value = "/refresh")
+    public ResponseEntity<Void> refreshRan() {
+        refresher.refresh();
+        log.info("Refreshed the items on request");
+        return ResponseEntity.ok().build();
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/controller/RanEventConfigureController.java b/src/main/java/org/onap/a1pesimulator/controller/RanEventConfigureController.java
new file mode 100644
index 0000000..5efe07a
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/controller/RanEventConfigureController.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.controller;
+
+import org.onap.a1pesimulator.data.ves.GlobalVesConfiguration;
+import org.onap.a1pesimulator.service.ves.RanVesBrokerService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping({"${restapi.version}/ran/eventConfig"})
+public class RanEventConfigureController {
+
+    private final RanVesBrokerService ranVesBrokerService;
+
+    public RanEventConfigureController(RanVesBrokerService ranVesBrokerService) {
+        this.ranVesBrokerService = ranVesBrokerService;
+    }
+
+    @GetMapping
+    public ResponseEntity<GlobalVesConfiguration> getEventConfig() {
+        GlobalVesConfiguration config = new GlobalVesConfiguration(ranVesBrokerService.getGlobalVesInterval(),
+                ranVesBrokerService.getGlobalPmVesStructure());
+        return ResponseEntity.ok(config);
+    }
+
+    @PostMapping
+    public ResponseEntity<Void> setEventConfig(final @RequestBody GlobalVesConfiguration config) {
+        ranVesBrokerService.setGlobalPmVesStructure(config.getEvent());
+        ranVesBrokerService.setGlobalVesInterval(config.getInterval());
+        return ResponseEntity.ok().build();
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/controller/RanPolicyController.java b/src/main/java/org/onap/a1pesimulator/controller/RanPolicyController.java
new file mode 100644
index 0000000..bfe645c
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/controller/RanPolicyController.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.controller;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import org.onap.a1pesimulator.service.a1.A1Service;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+
+@Controller
+public class RanPolicyController {
+
+    private final A1Service a1Service;
+
+    public RanPolicyController(A1Service a1Service) {
+        this.a1Service = a1Service;
+    }
+
+    /**
+     * Method for reading all policies of given policy type from A1 PE Simulator in one go
+     *
+     * @return Policy instance list for wanted policyType
+     * @throws IOException
+     * @throws URISyntaxException
+     */
+    @GetMapping(value = "${restapi.version}/ran/policies/{policyTypeId}")
+    public ResponseEntity<String> getAllPolicies(@PathVariable Integer policyTypeId)
+            throws IOException, URISyntaxException {
+        return a1Service.getAllPoliciesForType(policyTypeId);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/controller/RanUeController.java b/src/main/java/org/onap/a1pesimulator/controller/RanUeController.java
new file mode 100644
index 0000000..5cbaaba
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/controller/RanUeController.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.controller;
+
+import java.util.Optional;
+import org.onap.a1pesimulator.data.ue.RanUserEquipment;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.onap.a1pesimulator.service.ue.RanUeService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping({"${restapi.version}/ran/ues"})
+public class RanUeController {
+
+    private final RanUeService ranUeService;
+
+    public RanUeController(RanUeService ranUeService) {
+        this.ranUeService = ranUeService;
+    }
+
+    @GetMapping
+    public ResponseEntity<RanUserEquipment> getUes() {
+        return ResponseEntity.ok(ranUeService.getUes());
+    }
+
+    @GetMapping(value = "/{identifier}")
+    public ResponseEntity<UserEquipment> getUeById(final @PathVariable String identifier) {
+
+        Optional<UserEquipment> userEquipment = ranUeService.getUserEquipment(identifier);
+        return userEquipment.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
+
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/PolicyNotification.java b/src/main/java/org/onap/a1pesimulator/data/PolicyNotification.java
new file mode 100644
index 0000000..94f2160
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/PolicyNotification.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class PolicyNotification {
+
+    private String id;
+    private Integer typeId;
+    private PolicyNotificationActionEnum action;
+    private String content;
+
+    public PolicyNotification(String id, Integer typeId, PolicyNotificationActionEnum action) {
+        this.id = id;
+        this.typeId = typeId;
+        this.action = action;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/PolicyNotificationActionEnum.java b/src/main/java/org/onap/a1pesimulator/data/PolicyNotificationActionEnum.java
new file mode 100644
index 0000000..64531bc
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/PolicyNotificationActionEnum.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+@JsonFormat(shape = JsonFormat.Shape.OBJECT)
+public enum PolicyNotificationActionEnum {
+
+    CREATED("CREATED"), DELETED("DELETED");
+    public final String value;
+
+    PolicyNotificationActionEnum(String stateName) {
+        this.value = stateName;
+    }
+
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/Topology.java b/src/main/java/org/onap/a1pesimulator/data/Topology.java
new file mode 100644
index 0000000..0658787
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/Topology.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data;
+
+import java.util.Collection;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Topology {
+
+    Collection<CellDetails> cells;
+    Collection<UserEquipment> userEquipments;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/VnfConfig.java b/src/main/java/org/onap/a1pesimulator/data/VnfConfig.java
new file mode 100644
index 0000000..bd0e1d0
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/VnfConfig.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+
+
+@Getter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class VnfConfig {
+
+    @JsonProperty("vesHost")
+    private String vesHost;
+    @JsonProperty("vesPort")
+    private String vesPort;
+    @JsonProperty("vesUser")
+    private String vesUser;
+    @JsonProperty("vesPassword")
+    private String vesPassword;
+    @JsonProperty("vnfId")
+    private String vnfId;
+    @JsonProperty("vnfName")
+    private String vnfName;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/Cell.java b/src/main/java/org/onap/a1pesimulator/data/cell/Cell.java
new file mode 100644
index 0000000..8c8c0ce
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/Cell.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class Cell {
+
+    private String identifier;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/CellDetails.java b/src/main/java/org/onap/a1pesimulator/data/cell/CellDetails.java
new file mode 100644
index 0000000..249e26b
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/CellDetails.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.Collection;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+import org.onap.a1pesimulator.data.cell.state.CellStateMachine;
+import org.onap.a1pesimulator.data.cell.state.machine.InactiveState;
+
+@Getter
+@Builder
+public class CellDetails {
+
+    private String id;
+    private Double latitude;
+    private Double longitude;
+
+    @Setter
+    @JsonIgnore
+    @Builder.Default
+    private CellStateMachine cellStateMachine = new InactiveState();
+
+    @Setter
+    private Collection<String> connectedUserEquipments;
+
+    public void previousState() {
+        cellStateMachine.prev(this);
+    }
+
+    public void nextState() {
+        cellStateMachine.next(this);
+    }
+
+    @JsonProperty("currentState")
+    public CellStateEnum getCurrentState() {
+        return cellStateMachine.getState();
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/CellList.java b/src/main/java/org/onap/a1pesimulator/data/cell/CellList.java
new file mode 100644
index 0000000..627d43b
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/CellList.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.Collections;
+import java.util.List;
+import lombok.Getter;
+
+@Getter
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class CellList {
+
+    private final List<CellData> cellList;
+
+    public CellList() {
+        cellList = Collections.emptyList();
+    }
+
+    @Getter
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public static class CellData {
+
+        @JsonProperty("Cell")
+        private Cell cell;
+    }
+
+    @Getter
+    @JsonIgnoreProperties(ignoreUnknown = true)
+    public static class Cell {
+
+        private String nodeId;
+        private Double latitude;
+        private Double longitude;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/CellWithStatus.java b/src/main/java/org/onap/a1pesimulator/data/cell/CellWithStatus.java
new file mode 100644
index 0000000..f1419f7
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/CellWithStatus.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell;
+
+import lombok.Builder;
+import lombok.Getter;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+
+@Builder
+@Getter
+public class CellWithStatus {
+
+    private Cell cell;
+    private boolean vesEnabled;
+    private boolean failureMode;
+    private CellStateEnum state;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/RanCell.java b/src/main/java/org/onap/a1pesimulator/data/cell/RanCell.java
new file mode 100644
index 0000000..8ae9243
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/RanCell.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell;
+
+import java.util.Collection;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+@AllArgsConstructor
+public class RanCell {
+
+    private Collection<CellDetails> cells;
+    private int itemsLength;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/state/CellStateEnum.java b/src/main/java/org/onap/a1pesimulator/data/cell/state/CellStateEnum.java
new file mode 100644
index 0000000..a25156a
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/state/CellStateEnum.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell.state;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+@JsonFormat(shape = JsonFormat.Shape.OBJECT)
+public enum CellStateEnum {
+
+    INACTIVE("INACTIVE"), ACTIVE("ACTIVE"), GOING_TO_SLEEP("GOING_TO_SLEEP"), SLEEPING("SLEEPING");
+
+    public final String value;
+
+    CellStateEnum(String stateName) {
+        this.value = stateName;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/state/CellStateMachine.java b/src/main/java/org/onap/a1pesimulator/data/cell/state/CellStateMachine.java
new file mode 100644
index 0000000..f3c7bf0
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/state/CellStateMachine.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell.state;
+
+import org.onap.a1pesimulator.data.cell.CellDetails;
+
+public abstract class CellStateMachine {
+
+    private CellStateEnum state;
+
+    protected CellStateMachine(CellStateEnum state) {
+        this.state = state;
+    }
+
+    public abstract void next(CellDetails cell);
+
+    public abstract void prev(CellDetails cell);
+
+    public CellStateEnum getState() {
+        return state;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/ActiveState.java b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/ActiveState.java
new file mode 100644
index 0000000..c7d600d
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/ActiveState.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell.state.machine;
+
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+import org.onap.a1pesimulator.data.cell.state.CellStateMachine;
+
+public class ActiveState extends CellStateMachine {
+
+    public ActiveState() {
+        super(CellStateEnum.ACTIVE);
+    }
+
+    @Override
+    public void next(CellDetails cell) {
+        cell.setCellStateMachine(new GoingToSleepingState());
+    }
+
+    @Override
+    public void prev(CellDetails cell) {
+        cell.setCellStateMachine(new InactiveState());
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/GoingToSleepingState.java b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/GoingToSleepingState.java
new file mode 100644
index 0000000..d4bdc48
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/GoingToSleepingState.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell.state.machine;
+
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+import org.onap.a1pesimulator.data.cell.state.CellStateMachine;
+
+public class GoingToSleepingState extends CellStateMachine {
+
+    public GoingToSleepingState() {
+        super(CellStateEnum.GOING_TO_SLEEP);
+    }
+
+    @Override
+    public void next(CellDetails cell) {
+        cell.setCellStateMachine(new SleepingState());
+    }
+
+    @Override
+    public void prev(CellDetails cell) {
+        cell.setCellStateMachine(new InactiveState());
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/InactiveState.java b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/InactiveState.java
new file mode 100644
index 0000000..e04d5f7
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/InactiveState.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell.state.machine;
+
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+import org.onap.a1pesimulator.data.cell.state.CellStateMachine;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class InactiveState extends CellStateMachine {
+
+    private static final Logger log = LoggerFactory.getLogger(InactiveState.class);
+
+    public InactiveState() {
+        super(CellStateEnum.INACTIVE);
+    }
+
+    @Override
+    public void next(CellDetails cell) {
+        cell.setCellStateMachine(new ActiveState());
+    }
+
+    @Override
+    public void prev(CellDetails cell) {
+        log.info("YOU ARE IN THE INACTIVE STATE, PREVIOUS STATE ISN'T AVAILABLE");
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/SleepingState.java b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/SleepingState.java
new file mode 100644
index 0000000..7de3230
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/cell/state/machine/SleepingState.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.cell.state.machine;
+
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+import org.onap.a1pesimulator.data.cell.state.CellStateMachine;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SleepingState extends CellStateMachine {
+
+    private static final Logger log = LoggerFactory.getLogger(SleepingState.class);
+
+    public SleepingState() {
+        super(CellStateEnum.SLEEPING);
+    }
+
+    @Override
+    public void next(CellDetails cell) {
+        log.info("YOU ARE IN THE SLEEPING STATE, NEXT STATE ISN'T AVAILABLE");
+    }
+
+    @Override
+    public void prev(CellDetails cell) {
+        cell.setCellStateMachine(new InactiveState());
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ue/RanUserEquipment.java b/src/main/java/org/onap/a1pesimulator/data/ue/RanUserEquipment.java
new file mode 100644
index 0000000..a91a0d1
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ue/RanUserEquipment.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ue;
+
+import java.util.Collection;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+@AllArgsConstructor
+public class RanUserEquipment {
+
+    private Collection<UserEquipment> ues;
+    private int itemsLength;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ue/UserEquipment.java b/src/main/java/org/onap/a1pesimulator/data/ue/UserEquipment.java
new file mode 100644
index 0000000..8063527
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ue/UserEquipment.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ue;
+
+import java.util.Collection;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public class UserEquipment {
+
+    private String id;
+    private Double latitude;
+    private Double longitude;
+    @Setter
+    private String cellId;
+    @Setter
+    private Collection<String> cellsInRange;
+
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ue/UserEquipmentNotification.java b/src/main/java/org/onap/a1pesimulator/data/ue/UserEquipmentNotification.java
new file mode 100644
index 0000000..a294c26
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ue/UserEquipmentNotification.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ue;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class UserEquipmentNotification {
+
+    private String id;
+    private String cellId;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ves/CommonEventHeader.java b/src/main/java/org/onap/a1pesimulator/data/ves/CommonEventHeader.java
new file mode 100644
index 0000000..9cef221
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ves/CommonEventHeader.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ves;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class CommonEventHeader {
+
+    private String eventType;
+
+    private String version;
+
+    private String vesEventListenerVersion;
+
+    private String sourceId;
+
+    private String reportingEntityName;
+
+    private Long startEpochMicrosec;
+
+    private String eventId;
+
+    private Long lastEpochMicrosec;
+
+    private String priority;
+
+    private Integer sequence;
+
+    private String sourceName;
+
+    private String domain;
+
+    private String eventName;
+
+    private String reportingEntityId;
+
+    private String nfcNamingCode;
+
+    private String nfNamingCode;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ves/Event.java b/src/main/java/org/onap/a1pesimulator/data/ves/Event.java
new file mode 100644
index 0000000..ded1848
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ves/Event.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ves;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
+import com.fasterxml.jackson.annotation.JsonTypeInfo.Id;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonTypeName("event")
+@JsonTypeInfo(include = As.WRAPPER_OBJECT, use = Id.NAME)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class Event {
+
+    private CommonEventHeader commonEventHeader;
+    private FaultFields faultFields;
+
+    private MeasurementFields measurementFields;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ves/FaultFields.java b/src/main/java/org/onap/a1pesimulator/data/ves/FaultFields.java
new file mode 100644
index 0000000..f00e31d
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ves/FaultFields.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ves;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class FaultFields {
+
+    private Double faultFieldsVersion;
+    private String eventSeverity;
+    private String eventSourceType;
+    private String eventCategory;
+    private String alarmCondition;
+    private String specificProblem;
+    private String vfStatus;
+    private String alarmInterfaceA;
+    private List<AdditionalInformation> alarmAdditionalInformation;
+
+    @Data
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @JsonInclude(JsonInclude.Include.NON_NULL)
+    public static class AdditionalInformation {
+
+        private String name;
+        private String value;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ves/GlobalVesConfiguration.java b/src/main/java/org/onap/a1pesimulator/data/ves/GlobalVesConfiguration.java
new file mode 100644
index 0000000..7532573
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ves/GlobalVesConfiguration.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ves;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class GlobalVesConfiguration {
+
+    private Integer interval;
+    private Event event;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ves/MeasurementFields.java b/src/main/java/org/onap/a1pesimulator/data/ves/MeasurementFields.java
new file mode 100644
index 0000000..86af5d6
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ves/MeasurementFields.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ves;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import java.util.List;
+import java.util.Map;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_NULL)
+public class MeasurementFields {
+
+    private Integer measurementInterval;
+    private String measurementFieldsVersion;
+
+    private List<AdditionalMeasurement> additionalMeasurements;
+
+    @Data
+    @JsonInclude(JsonInclude.Include.NON_NULL)
+    public static class AdditionalMeasurement {
+
+        private String name;
+        private Map<String, String> hashMap;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ves/RanPeriodicVesEvent.java b/src/main/java/org/onap/a1pesimulator/data/ves/RanPeriodicVesEvent.java
new file mode 100644
index 0000000..908f66b
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ves/RanPeriodicVesEvent.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ves;
+
+import java.util.concurrent.ScheduledFuture;
+import lombok.Builder;
+import lombok.Data;
+import org.onap.a1pesimulator.service.ves.RanSendVesRunnable;
+
+@Data
+@Builder
+public class RanPeriodicVesEvent {
+
+    private Event event;
+    private Integer interval;
+    private ScheduledFuture<?> scheduledFuture;
+    private RanSendVesRunnable sendVesRunnable;
+}
diff --git a/src/main/java/org/onap/a1pesimulator/data/ves/VesEventStatusNotification.java b/src/main/java/org/onap/a1pesimulator/data/ves/VesEventStatusNotification.java
new file mode 100644
index 0000000..c356e4c
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/data/ves/VesEventStatusNotification.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.data.ves;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class VesEventStatusNotification {
+
+    String identifier;
+    Status status;
+
+    public enum Status {
+        STARTED, STOPPED;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/exception/LackOfConfigException.java b/src/main/java/org/onap/a1pesimulator/exception/LackOfConfigException.java
new file mode 100644
index 0000000..f33384e
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/exception/LackOfConfigException.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.exception;
+
+public class LackOfConfigException extends Exception {
+
+    public LackOfConfigException(String errorMessage) {
+        super(errorMessage);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/exception/VesBrokerException.java b/src/main/java/org/onap/a1pesimulator/exception/VesBrokerException.java
new file mode 100644
index 0000000..2366c31
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/exception/VesBrokerException.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.exception;
+
+public class VesBrokerException extends Exception {
+
+    public VesBrokerException(String errorMessage) {
+        super(errorMessage);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/a1/A1Service.java b/src/main/java/org/onap/a1pesimulator/service/a1/A1Service.java
new file mode 100644
index 0000000..aa2c407
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/a1/A1Service.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.a1;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestClientException;
+
+public interface A1Service {
+
+    ResponseEntity<String> healthCheck() throws URISyntaxException;
+
+    ResponseEntity<String> putPolicy(Integer policyTypeId, String policyId, String body) throws URISyntaxException;
+
+    ResponseEntity<String> putPolicySchema(Integer policyTypeId, String body) throws URISyntaxException;
+
+    ResponseEntity<String> deletePolicy(Integer policyTypeId, String policyId) throws URISyntaxException;
+
+    ResponseEntity<String> getPolicyTypeIds() throws RestClientException, URISyntaxException;
+
+    ResponseEntity<String> getPolicyType(Integer policyTypeId) throws RestClientException, URISyntaxException;
+
+    ResponseEntity<String> getPolicyIdsOfType(Integer policyTypeId)
+            throws RestClientException, URISyntaxException, IOException;
+
+    ResponseEntity<String> getPolicy(Integer policyTypeId, String policyInstanceId)
+            throws RestClientException, URISyntaxException;
+
+    ResponseEntity<String> getAllPoliciesForType(Integer policyTypeId)
+            throws IOException, RestClientException, URISyntaxException;
+
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/a1/OnPolicyAction.java b/src/main/java/org/onap/a1pesimulator/service/a1/OnPolicyAction.java
new file mode 100644
index 0000000..821e395
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/a1/OnPolicyAction.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.a1;
+
+public interface OnPolicyAction {
+
+    boolean isForMe(Integer policyTypeId, String policyId, String body);
+
+    void onPolicy(Integer policyTypeId, String policyId, String body);
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/a1/PolicyInstancesHolder.java b/src/main/java/org/onap/a1pesimulator/service/a1/PolicyInstancesHolder.java
new file mode 100644
index 0000000..a5e5a07
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/a1/PolicyInstancesHolder.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.a1;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.onap.a1pesimulator.util.JsonUtils;
+import org.springframework.stereotype.Service;
+
+@Service
+public class PolicyInstancesHolder {
+
+    Map<String, String> cellPolicyMap = new HashMap<>();
+
+    public void addPolicy(String policyId, String body) {
+        cellPolicyMap.put(policyId, body);
+    }
+
+    public void removePolicy(String policyId) {
+        cellPolicyMap.remove(policyId);
+    }
+
+    public boolean containsPoliciesForCell(String cell) {
+        return cellPolicyMap.values().stream().map(this::getCellListFromPolicyInstance).flatMap(List::stream)
+                       .anyMatch(c -> c.equals(cell));
+    }
+
+    private List<String> getCellListFromPolicyInstance(String policyInstance) {
+        RanUeHandoverOnPolicyAction.UeHandoverPolicy policy =
+                JsonUtils.INSTANCE.deserialize(policyInstance, RanUeHandoverOnPolicyAction.UeHandoverPolicy.class);
+        return policy.getResources().stream().flatMap(resources -> resources.getCellIdList().stream())
+                       .collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/a1/RanA1ServiceLocalStoreImpl.java b/src/main/java/org/onap/a1pesimulator/service/a1/RanA1ServiceLocalStoreImpl.java
new file mode 100644
index 0000000..feb481d
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/a1/RanA1ServiceLocalStoreImpl.java
@@ -0,0 +1,116 @@
+package org.onap.a1pesimulator.service.a1;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestClientException;
+
+/**
+ * A1 Service implementation which uses in-memory policy data store.
+ */
+@Service
+public class RanA1ServiceLocalStoreImpl implements A1Service {
+
+    private static final Logger log = LoggerFactory.getLogger(RanA1ServiceLocalStoreImpl.class);
+
+    private Map<Integer, Map<String, String>> policyTypesMap = new HashMap<>();
+    private Map<Integer, String> policySchemaMap = new HashMap<>();
+    private ObjectMapper mapper;
+
+    public RanA1ServiceLocalStoreImpl(ObjectMapper mapper) {
+        this.mapper = mapper;
+    }
+
+    @Override
+    public ResponseEntity<String> healthCheck() throws RestClientException {
+        return ResponseEntity.ok().build();
+    }
+
+    @Override
+    public ResponseEntity<String> putPolicySchema(Integer policyTypeId, String body) {
+        policySchemaMap.put(policyTypeId, body);
+        return new ResponseEntity<>(HttpStatus.CREATED);
+    }
+
+    @Override
+    public ResponseEntity<String> putPolicy(final Integer policyTypeId, final String policyId, final String body) {
+        log.debug("Create or update policy id {} of policy type id {} with following content {} ", policyId,
+                policyTypeId, body);
+        if (policyTypesMap.containsKey(policyTypeId)) {
+            policyTypesMap.get(policyTypeId).put(policyId, body);
+        } else {
+            Map<String, String> policies = new HashMap<>();
+            policies.put(policyId, body);
+            policyTypesMap.put(policyTypeId, policies);
+        }
+        return ResponseEntity.accepted().build();
+    }
+
+    @Override
+    public ResponseEntity<String> deletePolicy(final Integer policyTypeId, final String policyId) {
+        log.debug("Delete policy id {} of policy type id {}", policyId, policyTypeId);
+        if (policyTypesMap.containsKey(policyTypeId)) {
+            policyTypesMap.get(policyTypeId).remove(policyId);
+            return ResponseEntity.accepted().build();
+        } else {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    @Override
+    public ResponseEntity<String> getPolicyTypeIds() throws RestClientException {
+        return getRestAsString(policySchemaMap.keySet());
+    }
+
+    @Override
+    public ResponseEntity<String> getPolicyType(final Integer policyTypeId) throws RestClientException {
+        if (policySchemaMap.isEmpty() || !policySchemaMap.containsKey(policyTypeId)) {
+            return ResponseEntity.notFound().build();
+        } else {
+            return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(policySchemaMap.get(policyTypeId));
+        }
+    }
+
+    @Override
+    public ResponseEntity<String> getPolicyIdsOfType(final Integer policyTypeId) throws RestClientException {
+        Set<String> result = new HashSet<>();
+        if (policyTypesMap.containsKey(policyTypeId)) {
+            result = policyTypesMap.get(policyTypeId).keySet();
+        }
+        return getRestAsString(result);
+    }
+
+    @Override
+    public ResponseEntity<String> getPolicy(final Integer policyTypeId, final String policyId)
+            throws RestClientException {
+        if (policyTypesMap.containsKey(policyTypeId) && policyTypesMap.get(policyTypeId).containsKey(policyId)) {
+            return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON)
+                           .body(policyTypesMap.get(policyTypeId).get(policyId));
+        } else {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+    @Override
+    public ResponseEntity<String> getAllPoliciesForType(final Integer policyTypeId) throws RestClientException {
+        return getRestAsString(policyTypesMap.get(policyTypeId));
+    }
+
+    private ResponseEntity<String> getRestAsString(Object obj) throws RestClientException {
+        try {
+            return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(mapper.writeValueAsString(obj));
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException("Cannot serialize object", e);
+        }
+    }
+
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/a1/RanUeHandoverOnPolicyAction.java b/src/main/java/org/onap/a1pesimulator/service/a1/RanUeHandoverOnPolicyAction.java
new file mode 100644
index 0000000..fdbbd97
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/a1/RanUeHandoverOnPolicyAction.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.a1;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import lombok.Getter;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.onap.a1pesimulator.data.ue.UserEquipmentNotification;
+import org.onap.a1pesimulator.service.cell.RanCellService;
+import org.onap.a1pesimulator.service.ue.RanUeService;
+import org.onap.a1pesimulator.util.JsonUtils;
+import org.onap.a1pesimulator.util.JsonUtils.JsonUtilsException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanUeHandoverOnPolicyAction implements OnPolicyAction {
+
+    private static final String TOPIC_UE = "/topic/userEquipment";
+    private static final String POLICY_EXAMPLE =
+            "{ \"scope\": { \"ueId\": \"emergency_samsung_s10_01\" }, \"resources\": [ { \"cellIdList\": [ \"Cell1\" ], \"preference\": \"AVOID\" } ] }";
+    private static final Logger log = LoggerFactory.getLogger(RanUeHandoverOnPolicyAction.class);
+
+    private final RanUeService ranUeService;
+    private final SimpMessagingTemplate messagingTemplate;
+    private final RanCellService ranCellService;
+    private final PolicyInstancesHolder policyHolder;
+
+    public RanUeHandoverOnPolicyAction(SimpMessagingTemplate messagingTemplate, RanUeService ranUeService,
+            RanCellService ranCellService, PolicyInstancesHolder policyHolder) {
+        this.messagingTemplate = messagingTemplate;
+        this.ranUeService = ranUeService;
+        this.ranCellService = ranCellService;
+        this.policyHolder = policyHolder;
+    }
+
+    @Override
+    public boolean isForMe(Integer policyTypeId, String policyId, String body) {
+        try {
+            JsonUtils.INSTANCE.deserialize(body, UeHandoverPolicy.class);
+            return true;
+        } catch (JsonUtilsException ex) {
+            log.info(
+                    "Policy {} is not for me because policy body doesn't comply with Ue Handover policy. Follow example: {}",
+                    policyId, POLICY_EXAMPLE);
+            return false;
+        }
+    }
+
+    @Override
+    public void onPolicy(Integer policyTypeId, String policyId, String body) {
+        UeHandoverPolicy policy = JsonUtils.INSTANCE.deserialize(body, UeHandoverPolicy.class);
+        String ueId = policy.getScope().getUeId();
+        List<String> cellId = policy.getResources().stream().flatMap(resources -> resources.getCellIdList().stream())
+                                      .collect(Collectors.toList());
+
+        if (ueId == null || cellId.isEmpty()) {
+            log.warn("Cannot handover because {} is not provided in preload! Follow example: {}",
+                    ueId == null ? "ueId" : "cellId", POLICY_EXAMPLE);
+            return;
+        }
+
+        Optional<String> activeCellId = getActiveCellForUE(ueId);
+
+        if (!activeCellId.isPresent()) {
+            log.warn("Cannot handover ue {} because there is no active cell in range", ueId);
+            return;
+        }
+
+        ranUeService.handover(ueId, activeCellId.get());
+        messagingTemplate.convertAndSend(TOPIC_UE, new UserEquipmentNotification(ueId, activeCellId.get()));
+    }
+
+    private Optional<String> getActiveCellForUE(String ue) {
+        Optional<UserEquipment> equipment = ranUeService.getUserEquipment(ue);
+        if (!equipment.isPresent()) {
+            log.warn("Cannot handover because is not ue with id: {}", ue);
+            return Optional.empty();
+        }
+
+        return ranCellService.getAllCellsWithStatus().stream().filter(c -> !c.isFailureMode())
+                       .map(cellWithStatus -> cellWithStatus.getCell().getIdentifier())
+                       .filter(cell -> ranUeService.canHandover(ue, cell))
+                       .filter(cell -> !policyHolder.containsPoliciesForCell(cell)).findFirst();
+    }
+
+    @Getter
+    public static class UeHandoverPolicy {
+
+        private Scope scope;
+        private List<Resources> resources;
+    }
+
+    @Getter
+    public static class Scope {
+
+        private String ueId;
+    }
+
+    @Getter
+    public static class Resources {
+
+        private List<String> cellIdList;
+        private Preference preference;
+    }
+
+    public enum Preference {
+        SHALL("SHALL"), PREFER("PREFER"), AVOID("AVOID"), FORBID("FORBID");
+        public final String value;
+
+        Preference(String stateName) {
+            this.value = stateName;
+        }
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/a1/SetLowRangeValuesOnPolicyAction.java b/src/main/java/org/onap/a1pesimulator/service/a1/SetLowRangeValuesOnPolicyAction.java
new file mode 100644
index 0000000..e608aa5
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/a1/SetLowRangeValuesOnPolicyAction.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.a1;
+
+import java.util.List;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.MeasurementFields.AdditionalMeasurement;
+import org.onap.a1pesimulator.data.ves.RanPeriodicVesEvent;
+import org.onap.a1pesimulator.service.ves.RanVesBrokerService;
+import org.onap.a1pesimulator.util.JsonUtils;
+import org.onap.a1pesimulator.util.RanVesUtils;
+import org.springframework.stereotype.Service;
+
+@Service
+public class SetLowRangeValuesOnPolicyAction implements OnPolicyAction {
+
+    private final RanVesBrokerService vesBrokerService;
+
+    public SetLowRangeValuesOnPolicyAction(RanVesBrokerService vesBrokerService) {
+        this.vesBrokerService = vesBrokerService;
+    }
+
+    @Override
+    public boolean isForMe(Integer policyTypeId, String policyId, String body) {
+        // disabling for now
+        return false;
+    }
+
+    @Override
+    public void onPolicy(Integer policyTypeId, String policyId, String body) {
+        vesBrokerService.getPeriodicEventsCache().values().forEach(this::updateEvent);
+    }
+
+    private void updateEvent(RanPeriodicVesEvent periodicEvent) {
+        List<AdditionalMeasurement> lowRangeValues = RanVesUtils.setLowRangeValues(
+                periodicEvent.getEvent().getMeasurementFields().getAdditionalMeasurements());
+        Event clonedEvent = JsonUtils.INSTANCE.clone(periodicEvent.getEvent());
+        clonedEvent.getMeasurementFields().setAdditionalMeasurements(lowRangeValues);
+        periodicEvent.getSendVesRunnable().updateEvent(clonedEvent);
+    }
+
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/cell/RanCellService.java b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellService.java
new file mode 100644
index 0000000..a12ed2c
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellService.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.cell;
+
+import java.util.Collection;
+import java.util.Set;
+import org.onap.a1pesimulator.data.Topology;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.CellWithStatus;
+import org.onap.a1pesimulator.data.cell.RanCell;
+
+public interface RanCellService {
+
+    Topology getTopology();
+
+    Set<String> getCellIds();
+
+    CellDetails getCellById(String id);
+
+    RanCell getCells();
+
+    void failure(String id);
+
+    void recoverFromFailure(String id);
+
+    Collection<CellWithStatus> getAllCellsWithStatus();
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/a1pesimulator/service/cell/RanCellServiceImpl.java b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellServiceImpl.java
new file mode 100644
index 0000000..0c0ab00
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellServiceImpl.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.cell;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.onap.a1pesimulator.data.Topology;
+import org.onap.a1pesimulator.data.cell.Cell;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.CellWithStatus;
+import org.onap.a1pesimulator.data.cell.RanCell;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.onap.a1pesimulator.service.ue.RanUeHolder;
+import org.onap.a1pesimulator.service.ves.RanVesHolder;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanCellServiceImpl implements RanCellService {
+
+    private final RanCellsHolder ranCellsHolder;
+    private final RanUeHolder ueHolder;
+    private final RanVesHolder vesHolder;
+
+    public RanCellServiceImpl(RanCellsHolder ranCellsHolder, RanUeHolder ueHolder, RanVesHolder vesHolder) {
+        this.ranCellsHolder = ranCellsHolder;
+        this.ueHolder = ueHolder;
+        this.vesHolder = vesHolder;
+    }
+
+    @Override
+    public Set<String> getCellIds() {
+        return ranCellsHolder.getCellIds();
+    }
+
+    @Override
+    public CellDetails getCellById(String id) {
+        CellDetails cellDetails = ranCellsHolder.getCellById(id);
+        cellDetails.setConnectedUserEquipments(getConnectedUserEquipments(cellDetails.getId()));
+        return cellDetails;
+    }
+
+    @Override
+    public RanCell getCells() {
+        Collection<CellDetails> cellDetails = ranCellsHolder.getAllCells();
+        cellDetails.forEach(cell -> cell.setConnectedUserEquipments(getConnectedUserEquipments(cell.getId())));
+        return new RanCell(cellDetails, cellDetails.size());
+    }
+
+    @Override
+    public Topology getTopology() {
+        Collection<CellDetails> cellList = ranCellsHolder.getCellDetailsList();
+        cellList.forEach(cell -> cell.setConnectedUserEquipments(getConnectedUserEquipments(cell.getId())));
+        return Topology.builder().cells(cellList).userEquipments(ueHolder.getUserEquipments()).build();
+    }
+
+    private Set<String> getConnectedUserEquipments(String cellId) {
+        Collection<UserEquipment> cellUes = ueHolder.getUserEquipmentsConnectedToCell(cellId);
+        return cellUes.stream().map(UserEquipment::getId).collect(Collectors.toSet());
+    }
+
+    @Override
+    public void failure(String id) {
+        ranCellsHolder.markCellInFailure(id);
+    }
+
+    @Override
+    public void recoverFromFailure(String id) {
+        ranCellsHolder.unmarkCellInFailure(id);
+    }
+
+    @Override
+    public Collection<CellWithStatus> getAllCellsWithStatus() {
+        return ranCellsHolder.getAllCells().stream().map(this::wrapCellWithStatus).collect(Collectors.toList());
+    }
+
+    private CellWithStatus wrapCellWithStatus(CellDetails cell) {
+        Cell c = Cell.builder().identifier(cell.getId()).build();
+        return CellWithStatus.builder().cell(c).failureMode(ranCellsHolder.isInFailureMode(cell.getId()))
+                       .vesEnabled(vesHolder.isEventEnabled(cell.getId())).state(cell.getCurrentState()).build();
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/cell/RanCellStateService.java b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellStateService.java
new file mode 100644
index 0000000..d69629e
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellStateService.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.cell;
+
+import java.util.Optional;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanCellStateService {
+
+    private static final Logger log = LoggerFactory.getLogger(RanCellStateService.class);
+
+    private final RanCellsHolder cellsHolder;
+    private final SimpMessagingTemplate messagingTemplate;
+
+    public static final String TOPIC_CELL = "/topic/cellStatus";
+
+    public RanCellStateService(RanCellsHolder cellsHolder, SimpMessagingTemplate messagingTemplate) {
+        this.cellsHolder = cellsHolder;
+        this.messagingTemplate = messagingTemplate;
+    }
+
+    public void activateState(String identifier) {
+        Optional<CellDetails> cellDetails = getCell(identifier);
+        if (cellExist(cellDetails, identifier, "Activate")) {
+            boolean changed = nextStateIfPossible(cellDetails.get(), CellStateEnum.INACTIVE);
+            if (changed) {
+                sendCellNotification(cellDetails.get());
+            }
+        }
+    }
+
+    public void failingState(String identifier) {
+        Optional<CellDetails> cellDetails = getCell(identifier);
+        if (cellExist(cellDetails, identifier, "Failing")) {
+            boolean changed = nextStateIfPossible(cellDetails.get(), CellStateEnum.ACTIVE);
+            if (changed) {
+                sendCellNotification(cellDetails.get());
+            }
+        }
+    }
+
+    public void stopState(String identifier) {
+        Optional<CellDetails> cellDetails = getCell(identifier);
+        if (cellExist(cellDetails, identifier, "Stop")) {
+            boolean changed = previousStateIfPossible(cellDetails.get());
+            if (changed) {
+                sendCellNotification(cellDetails.get());
+            }
+        }
+    }
+
+    private boolean cellExist(Optional<CellDetails> cellDetails, String identifier, String actionName) {
+        if (cellDetails.isEmpty()) {
+            log.info("Cell not found for {} identifier! '{}' action won't be executed!", identifier, actionName);
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean previousStateIfPossible(CellDetails cell) {
+
+        CellStateEnum state = cell.getCellStateMachine().getState();
+        if (state == CellStateEnum.SLEEPING || state == CellStateEnum.GOING_TO_SLEEP || state == CellStateEnum.ACTIVE) {
+            cell.previousState();
+        } else {
+            log.info("Cell {} is in {} state! The changing of the state isn't allowed."
+                             + "Supported states are: GOING_TO_SLEEP, SLEEPING, ACTIVE.", cell.getId(),
+                    cell.getCellStateMachine().getState().value);
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean nextStateIfPossible(CellDetails cellDetails, CellStateEnum shouldBe) {
+
+        if (cellDetails.getCellStateMachine().getState() == shouldBe) {
+            cellDetails.nextState();
+        } else {
+            log.info(
+                    "Cell {} is in {} state. The changing of the state isn't allowed. " + "The supported state is: {}!",
+                    cellDetails.getId(), cellDetails.getCellStateMachine().getState().value, shouldBe.value);
+            return false;
+        }
+
+        return true;
+    }
+
+    private Optional<CellDetails> getCell(String identifier) {
+        CellDetails cell = null;
+        try {
+            cell = cellsHolder.getCellById(identifier);
+        } catch (RuntimeException e) {
+            log.info("Exception was thrown: ", e);
+        }
+
+        if (cell == null) {
+            return Optional.empty();
+        }
+
+        return Optional.of(cell);
+    }
+
+    private void sendCellNotification(CellDetails cellDetails) {
+        messagingTemplate.convertAndSend(TOPIC_CELL, cellDetails);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/cell/RanCellsHolder.java b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellsHolder.java
new file mode 100644
index 0000000..86fa32c
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/cell/RanCellsHolder.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.cell;
+
+import java.text.MessageFormat;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.function.BinaryOperator;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.CellList.Cell;
+import org.onap.a1pesimulator.data.cell.CellList.CellData;
+import org.onap.a1pesimulator.util.TopologyReader;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanCellsHolder {
+
+    private Map<String, CellDetails> cellDetailsById;
+    private final Collection<CellInFailureMode> cellsInFailureMode = new HashSet<>();
+
+    private final TopologyReader topologyReader;
+
+    public RanCellsHolder(TopologyReader topologyReader) {
+        this.topologyReader = topologyReader;
+        refresh();
+    }
+
+    public Set<String> getCellIds() {
+        return cellDetailsById.keySet();
+    }
+
+    public CellDetails getCellById(String id) {
+        if (!cellDetailsById.containsKey(id)) {
+            throw new RuntimeException(MessageFormat.format("Cell not found: {0}", id));
+        }
+        return cellDetailsById.get(id);
+    }
+
+    public Collection<CellDetails> getCellDetailsList() {
+        return cellDetailsById.values();
+    }
+
+    public Collection<CellDetails> getAllCells() {
+        return cellDetailsById.values();
+    }
+
+    public void markCellInFailure(String id) {
+        cellsInFailureMode.add(CellInFailureMode.builder().id(id).build());
+    }
+
+    public boolean isInFailureMode(String id) {
+        return cellsInFailureMode.stream().anyMatch(byIdPredicate(id));
+    }
+
+    public void unmarkCellInFailure(String id) {
+        cellsInFailureMode.removeIf(byIdPredicate(id));
+    }
+
+    public Optional<CellInFailureMode> getCellsInFailureMode(String id) {
+        return cellsInFailureMode.stream().filter(byIdPredicate(id)).findFirst();
+    }
+
+    @Getter
+    @Builder
+    public static class CellInFailureMode {
+
+        private final String id;
+        @Setter
+        private Long sleepingModeDetectedTime;
+    }
+
+    public void refresh() {
+        List<CellData> cellDatas = topologyReader.loadCellTopology().getCellList();
+        cellDetailsById = cellDatas.stream().collect(Collectors.toMap(cellData -> cellData.getCell().getNodeId(),
+                this::toCellDetails, throwingMerger(), TreeMap::new));
+    }
+
+    public boolean hasChanged() {
+        return topologyReader.topologyCellHasChanged();
+    }
+
+    private <T> BinaryOperator<T> throwingMerger() {
+        return (u, v) -> {
+            throw new IllegalStateException(String.format("Duplicate key %s", u));
+        };
+    }
+
+    private CellDetails toCellDetails(CellData data) {
+        Cell cell = data.getCell();
+        return CellDetails.builder().id(cell.getNodeId()).latitude(cell.getLatitude()).longitude(cell.getLongitude())
+                       .build();
+    }
+
+    public static Predicate<CellInFailureMode> byIdPredicate(String id) {
+        return cell -> cell.getId().equals(id);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/distance/DistanceService.java b/src/main/java/org/onap/a1pesimulator/service/distance/DistanceService.java
new file mode 100644
index 0000000..18462e5
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/distance/DistanceService.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.distance;
+
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.onap.a1pesimulator.util.DistanceCalculator;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Service
+public class DistanceService {
+
+    private Double cellRange;
+
+    public DistanceService(@Value("${topology.cell.range}") Double cellRange) {
+        this.cellRange = cellRange;
+    }
+
+    public boolean isInRange(CellDetails cell, UserEquipment ue) {
+        return DistanceCalculator
+                       .isInRange(cell.getLatitude(), cell.getLongitude(), ue.getLatitude(), ue.getLongitude(),
+                               cellRange);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ue/RanUeHolder.java b/src/main/java/org/onap/a1pesimulator/service/ue/RanUeHolder.java
new file mode 100644
index 0000000..d31135d
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ue/RanUeHolder.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ue;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.onap.a1pesimulator.service.cell.RanCellsHolder;
+import org.onap.a1pesimulator.service.distance.DistanceService;
+import org.onap.a1pesimulator.util.TopologyReader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanUeHolder {
+
+    private static final Logger log = LoggerFactory.getLogger(RanUeHolder.class);
+
+    private Map<String, UserEquipment> userEquipmentsById;
+
+    private final TopologyReader topologyReader;
+    private final DistanceService distanceService;
+
+    private final RanCellsHolder ranCellsHolder;
+
+    public RanUeHolder(TopologyReader topologyReader, DistanceService distanceService, RanCellsHolder ranCellsHolder) {
+        this.topologyReader = topologyReader;
+        this.distanceService = distanceService;
+        this.ranCellsHolder = ranCellsHolder;
+        refresh();
+    }
+
+    public Collection<UserEquipment> getUserEquipments() {
+        return userEquipmentsById.values();
+    }
+
+    public Collection<UserEquipment> getUserEquipmentsConnectedToCell(String cellId) {
+        return userEquipmentsById.values().stream().filter(ue -> cellId.equalsIgnoreCase(ue.getCellId()))
+                       .collect(Collectors.toList());
+    }
+
+    public Optional<UserEquipment> getUserEquipment(String id) {
+        return userEquipmentsById.values().stream().filter(ue -> id.equalsIgnoreCase(ue.getId())).findAny();
+    }
+
+    public void refresh() {
+        Collection<UserEquipment> ues = topologyReader.loadUeTopology();
+        userEquipmentsById = ues.stream().filter(this::validate)
+                                     .collect(Collectors.toMap(UserEquipment::getId, Function.identity()));
+    }
+
+    public boolean hasChanged() {
+        return topologyReader.topologyUeHasChanged();
+    }
+
+    private boolean validate(UserEquipment ue) {
+        CellDetails cell = ranCellsHolder.getCellById(ue.getCellId());
+        boolean inRange = distanceService.isInRange(cell, ue);
+        if (!inRange) {
+            log.warn("UE {} is not in range of preferred cell {}", ue.getId(), cell.getId());
+        }
+        return true;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ue/RanUeService.java b/src/main/java/org/onap/a1pesimulator/service/ue/RanUeService.java
new file mode 100644
index 0000000..556ed23
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ue/RanUeService.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ue;
+
+import java.util.Collection;
+import java.util.Optional;
+import org.onap.a1pesimulator.data.ue.RanUserEquipment;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+
+public interface RanUeService {
+
+    Collection<UserEquipment> getUserEquipments();
+
+    Collection<UserEquipment> getUserEquipmentsConnectedToCell(String cellId);
+
+    Optional<UserEquipment> getUserEquipment(String id);
+
+    RanUserEquipment getUes();
+
+    void handover(String ueId, String cellId);
+
+    boolean canHandover(String ueId, String cellId);
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ue/RanUeServiceImpl.java b/src/main/java/org/onap/a1pesimulator/service/ue/RanUeServiceImpl.java
new file mode 100644
index 0000000..da6f5bc
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ue/RanUeServiceImpl.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ue;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.ue.RanUserEquipment;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.onap.a1pesimulator.service.cell.RanCellsHolder;
+import org.onap.a1pesimulator.service.distance.DistanceService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanUeServiceImpl implements RanUeService {
+
+    private static final Logger log = LoggerFactory.getLogger(RanUeServiceImpl.class);
+
+    private final RanUeHolder ueHolder;
+    private final RanCellsHolder ranCellsHolder;
+    private final DistanceService distanceService;
+
+    public RanUeServiceImpl(RanUeHolder ueHolder, RanCellsHolder ranCellsHolder, DistanceService distanceService) {
+        this.ueHolder = ueHolder;
+        this.ranCellsHolder = ranCellsHolder;
+        this.distanceService = distanceService;
+    }
+
+    @Override
+    public Collection<UserEquipment> getUserEquipments() {
+        return ueHolder.getUserEquipments();
+    }
+
+    @Override
+    public RanUserEquipment getUes() {
+        Collection<UserEquipment> uesCollection = ueHolder.getUserEquipments();
+        return new RanUserEquipment(uesCollection, uesCollection.size());
+    }
+
+    @Override
+    public Collection<UserEquipment> getUserEquipmentsConnectedToCell(String cellId) {
+        return ueHolder.getUserEquipmentsConnectedToCell(cellId);
+    }
+
+    @Override
+    public Optional<UserEquipment> getUserEquipment(String id) {
+        Optional<UserEquipment> userEquipment = ueHolder.getUserEquipment(id);
+        userEquipment.ifPresent(ue -> ue.setCellsInRange(getCellsIdsInRange(ue)));
+        return userEquipment;
+    }
+
+    @Override
+    public void handover(String ueId, String cellId) {
+        Optional<UserEquipment> userEquipment = getUserEquipment(ueId);
+        if (!userEquipment.isPresent()) {
+            log.warn("Cannot handover ue {} to cell {}, because ue does not exist!", ueId, cellId);
+            return;
+        }
+        userEquipment.get().setCellId(cellId);
+    }
+
+    @Override
+    public boolean canHandover(String ueId, String cellId) {
+        Optional<UserEquipment> userEquipment = getUserEquipment(ueId);
+        return userEquipment.map(equipment -> equipment.getCellsInRange().stream().anyMatch(cellId::equalsIgnoreCase))
+                       .orElse(false);
+    }
+
+    private Collection<String> getCellsIdsInRange(UserEquipment ue) {
+        return ranCellsHolder.getAllCells().stream().filter(cell -> distanceService.isInRange(cell, ue))
+                       .map(CellDetails::getId).collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/OnEventAction.java b/src/main/java/org/onap/a1pesimulator/service/ves/OnEventAction.java
new file mode 100644
index 0000000..b34594a
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/OnEventAction.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import org.onap.a1pesimulator.data.ves.Event;
+
+@FunctionalInterface
+public interface OnEventAction {
+
+    void onEvent(Event event);
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanCellEventCustomizer.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanCellEventCustomizer.java
new file mode 100644
index 0000000..9922329
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanCellEventCustomizer.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.util.List;
+import java.util.Optional;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.MeasurementFields.AdditionalMeasurement;
+import org.onap.a1pesimulator.service.ue.RanUeHolder;
+import org.onap.a1pesimulator.service.ves.RanSendVesRunnable.EventCustomizer;
+import org.onap.a1pesimulator.util.Constants;
+import org.onap.a1pesimulator.util.JsonUtils;
+import org.onap.a1pesimulator.util.RanVesUtils;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanCellEventCustomizer implements EventCustomizer {
+
+    private static final String UE_PARAM_TRAFFIC_MODEL_RANGE = "[[20-50]]";
+    private final RanUeHolder ranUeHolder;
+
+    public RanCellEventCustomizer(RanUeHolder ueHolder) {
+        this.ranUeHolder = ueHolder;
+    }
+
+    @Override
+    public Event apply(Event t) {
+        Event event = JsonUtils.INSTANCE.clone(t);
+        return customizeEvent(event);
+    }
+
+    private Event customizeEvent(Event event) {
+        RanVesUtils.updateHeader(event);
+        enrichWithUeData(event);
+        randomizeEvent(event);
+        return event;
+    }
+
+    private void randomizeEvent(Event event) {
+        List<AdditionalMeasurement> additionalMeasurementsToRandomize =
+                event.getMeasurementFields().getAdditionalMeasurements();
+        event.getMeasurementFields().setAdditionalMeasurements(
+                RanVesUtils.randomizeAdditionalMeasurements(additionalMeasurementsToRandomize));
+    }
+
+    private void enrichWithUeData(Event event) {
+
+        Optional<AdditionalMeasurement> identity = event.getMeasurementFields().getAdditionalMeasurements().stream()
+                                                           .filter(msrmnt -> Constants.MEASUREMENT_FIELD_IDENTIFIER
+                                                                                     .equalsIgnoreCase(
+                                                                                             msrmnt.getName()))
+                                                           .findAny();
+        identity.ifPresent(m -> addTrafficModelMeasurement(event, m));
+    }
+
+    private void addTrafficModelMeasurement(Event event, AdditionalMeasurement identity) {
+        AdditionalMeasurement trafficModelMeasurement =
+                RanVesUtils.buildTrafficModelMeasurement(identity, ranUeHolder, UE_PARAM_TRAFFIC_MODEL_RANGE);
+        event.getMeasurementFields().getAdditionalMeasurements().add(trafficModelMeasurement);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanCellFailureEventCustomizer.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanCellFailureEventCustomizer.java
new file mode 100644
index 0000000..ac2c4fc
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanCellFailureEventCustomizer.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.text.MessageFormat;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.MeasurementFields.AdditionalMeasurement;
+import org.onap.a1pesimulator.service.ue.RanUeHolder;
+import org.onap.a1pesimulator.service.ves.RanSendVesRunnable.EventCustomizer;
+import org.onap.a1pesimulator.util.Constants;
+import org.onap.a1pesimulator.util.JsonUtils;
+import org.onap.a1pesimulator.util.RanVesUtils;
+
+public class RanCellFailureEventCustomizer implements EventCustomizer {
+
+    private static final String UE_PARAM_TRAFFIC_MODEL_RANGE = "[[50->10]]";
+    private final RanUeHolder ranUeHolder;
+    private final Event event;
+
+    private final Map<Key, Value> additionalMeasurementsValues = new HashMap<>();
+    private final ValueFactory valueFactory;
+
+    public RanCellFailureEventCustomizer(Event event, RanUeHolder ranUeHolder) {
+        this.ranUeHolder = ranUeHolder;
+        this.event = event;
+        valueFactory = new ValueFactory();
+        collectAdditionalMeasurementValues(event);
+    }
+
+    @Override
+    public Event apply(Event t) {
+        return customizeEvent(JsonUtils.INSTANCE.clone(this.event));
+    }
+
+    private void collectAdditionalMeasurementValues(Event event) {
+        Collection<AdditionalMeasurement> additionalMeasurementsToResolve =
+                event.getMeasurementFields().getAdditionalMeasurements();
+        additionalMeasurementsToResolve.forEach(this::collectAdditionalMeasurementValue);
+    }
+
+    private void collectAdditionalMeasurementValue(AdditionalMeasurement m) {
+        for (Entry<String, String> entry : m.getHashMap().entrySet()) {
+            if (!RanVesUtils.isRange(entry.getValue())) {
+                continue;
+            }
+            additionalMeasurementsValues
+                    .putIfAbsent(new Key(m.getName(), entry.getKey()), valueFactory.getInstance(entry.getValue()));
+        }
+    }
+
+    private Event customizeEvent(Event event) {
+        RanVesUtils.updateHeader(event);
+        enrichWithUeData(event);
+        resolveRanges(event);
+        return event;
+    }
+
+    private void resolveRanges(Event event) {
+        List<AdditionalMeasurement> additionalMeasurementsToResolve =
+                event.getMeasurementFields().getAdditionalMeasurements();
+
+        additionalMeasurementsToResolve.forEach(this::resolveRanges);
+        event.getMeasurementFields().setAdditionalMeasurements(additionalMeasurementsToResolve);
+    }
+
+    private void resolveRanges(AdditionalMeasurement m) {
+        for (Entry<String, String> entry : m.getHashMap().entrySet()) {
+            Key key = new Key(m.getName(), entry.getKey());
+            if (!additionalMeasurementsValues.containsKey(key)) {
+                continue;
+            }
+            Value value = additionalMeasurementsValues.get(key);
+            value.current = value.calculateCurrentValue();
+            entry.setValue(value.current.toString());
+        }
+    }
+
+    private void enrichWithUeData(Event event) {
+
+        Optional<AdditionalMeasurement> identity = event.getMeasurementFields().getAdditionalMeasurements().stream()
+                                                           .filter(msrmnt -> Constants.MEASUREMENT_FIELD_IDENTIFIER
+                                                                                     .equalsIgnoreCase(
+                                                                                             msrmnt.getName()))
+                                                           .findAny();
+        identity.ifPresent(m -> addTrafficModelMeasurement(event, m));
+    }
+
+    private void addTrafficModelMeasurement(Event event, AdditionalMeasurement identity) {
+        AdditionalMeasurement trafficModelMeasurement =
+                RanVesUtils.buildTrafficModelMeasurement(identity, ranUeHolder, UE_PARAM_TRAFFIC_MODEL_RANGE);
+        event.getMeasurementFields().getAdditionalMeasurements().add(trafficModelMeasurement);
+
+        collectAdditionalMeasurementValue(trafficModelMeasurement);
+    }
+
+    // -----------helper classes
+
+    private static class ValueFactory {
+
+        public Value getInstance(String value) {
+            String[] split;
+            if (RanVesUtils.isRandomRange(value)) {
+                split = RanVesUtils.splitRandomRange(value);
+                return new RandomValue(Integer.valueOf(split[0]), Integer.valueOf(split[1]));
+            }
+            if (RanVesUtils.isTrandingRange(value)) {
+                split = RanVesUtils.splitTrendingRange(value);
+                Integer start = Integer.valueOf(split[0]);
+                Integer end = Integer.valueOf(split[1]);
+                if (start < end) {
+                    return new RaisingValue(start, end);
+                } else if (start > end) {
+                    return new DecreasingValue(start, end);
+                }
+            }
+            throw new RuntimeException(MessageFormat.format("Cannot instantiate Value from string: {0}", value));
+        }
+    }
+
+    private abstract static class Value {
+
+        protected Integer start;
+        protected Integer end;
+        protected Integer current;
+
+        public Value(Integer start, Integer end) {
+            this.start = start;
+            this.end = end;
+        }
+
+        public abstract Integer calculateCurrentValue();
+    }
+
+    private static class RaisingValue extends Value {
+
+        private int increment;
+
+        public RaisingValue(Integer start, Integer end) {
+            super(start, end);
+        }
+
+        @Override
+        public Integer calculateCurrentValue() {
+            if (current == null) {
+                return start;
+            }
+            if (increment == 0) {
+                increment = 1;
+            } else {
+                increment = increment * 2;
+            }
+            Integer result = start + increment;
+            if (result > end) {
+                increment = 1;
+                return end;
+            }
+            return result;
+        }
+    }
+
+    private static class DecreasingValue extends Value {
+
+        private int decrement;
+
+        public DecreasingValue(Integer start, Integer end) {
+            super(start, end);
+        }
+
+        @Override
+        public Integer calculateCurrentValue() {
+            if (current == null) {
+                return start;
+            }
+            if (decrement == 0) {
+                decrement = 1;
+            } else {
+                decrement = decrement * 2;
+            }
+            Integer result = start - decrement;
+            if (result < end) {
+                return end;
+            }
+            return result;
+        }
+    }
+
+    private static class RandomValue extends Value {
+
+        public RandomValue(Integer start, Integer end) {
+            super(start, end);
+        }
+
+        @Override
+        public Integer calculateCurrentValue() {
+            return RanVesUtils.getRandomNumber(start, end);
+        }
+    }
+
+    @AllArgsConstructor
+    @EqualsAndHashCode
+    private static class Key {
+
+        private String paramName;
+        private String mapKey;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanCheckCellIsDeadOnEvent.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanCheckCellIsDeadOnEvent.java
new file mode 100644
index 0000000..1330e04
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanCheckCellIsDeadOnEvent.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import static org.onap.a1pesimulator.service.cell.RanCellStateService.TOPIC_CELL;
+
+import java.util.Optional;
+import org.onap.a1pesimulator.data.cell.CellDetails;
+import org.onap.a1pesimulator.data.cell.state.CellStateEnum;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.MeasurementFields;
+import org.onap.a1pesimulator.service.cell.RanCellsHolder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanCheckCellIsDeadOnEvent implements OnEventAction {
+
+    private static final Logger log = LoggerFactory.getLogger(RanCheckCellIsDeadOnEvent.class);
+
+    private final RanCellsHolder ranCellsHolder;
+    private final SimpMessagingTemplate messagingTemplate;
+
+    private final Integer failingModeThroughputValue;
+    private final Integer failingModeLatencyValue;
+    private final Integer failingCheckoutDelayTimeInSec;
+
+    private static final int TO_MICRO_SEC = 1_000_000;
+
+    public RanCheckCellIsDeadOnEvent(RanCellsHolder ranCellsHolder, SimpMessagingTemplate messagingTemplate,
+            @Value("${ves.failing.throughput}") Integer failingModeThroughputValue,
+            @Value("${ves.failing.latency}") Integer failingModeLatencyValue,
+            @Value("${ves.failing.checkout.delay}") Integer failingCheckoutDelayTimeInSec) {
+        this.ranCellsHolder = ranCellsHolder;
+        this.messagingTemplate = messagingTemplate;
+
+        this.failingModeThroughputValue = failingModeThroughputValue;
+        this.failingModeLatencyValue = failingModeLatencyValue;
+        this.failingCheckoutDelayTimeInSec = failingCheckoutDelayTimeInSec;
+    }
+
+    @Override
+    public void onEvent(Event event) {
+        Optional<String> cellId = getCellIdentifier(event);
+        Optional<String> throughput = getCellThroughput(event);
+        Optional<String> latency = getCellLatency(event);
+
+        if (cellId.isPresent() && throughput.isPresent() && latency.isPresent()) {
+            checkCell(cellId.get(), Integer.parseInt(throughput.get()), Integer.parseInt(latency.get()),
+                    event.getCommonEventHeader().getLastEpochMicrosec());
+        }
+    }
+
+    private void checkCell(String cellId, Integer throughput, Integer latency, Long lastEpochMicrosec) {
+        if (throughput <= failingModeThroughputValue && latency >= failingModeLatencyValue) {
+            log.info("Failure mode detected for cell {}", cellId);
+            processSleepingMode(cellId, lastEpochMicrosec);
+        }
+    }
+
+    private void processSleepingMode(String cellId, Long lastEpochMicrosec) {
+        CellDetails cell = ranCellsHolder.getCellById(cellId);
+        if (cell.getCellStateMachine().getState() == CellStateEnum.GOING_TO_SLEEP) {
+            Optional<RanCellsHolder.CellInFailureMode> cellInFailureModeOpt =
+                    ranCellsHolder.getCellsInFailureMode(cellId);
+            if (cellInFailureModeOpt.isPresent()) {
+                RanCellsHolder.CellInFailureMode cellInFailureMode = cellInFailureModeOpt.get();
+                if (cellInFailureMode.getSleepingModeDetectedTime() == null) {
+                    cellInFailureMode.setSleepingModeDetectedTime(lastEpochMicrosec);
+                } else {
+                    long waitingEpochMicrosec = addDelayTime(cellInFailureMode.getSleepingModeDetectedTime());
+                    if (lastEpochMicrosec >= waitingEpochMicrosec) {
+                        log.info("Cell {} is sleeping!", cellId);
+                        cell.nextState();
+                        messagingTemplate.convertAndSend(TOPIC_CELL, cell);
+                    }
+                }
+            }
+        }
+    }
+
+    private Optional<String> getCellIdentifier(Event event) {
+        return getValueFromAdditionalMeasurement(event, "identifier");
+    }
+
+    private Optional<String> getCellThroughput(Event event) {
+        return getValueFromAdditionalMeasurement(event, "throughput");
+    }
+
+    private Optional<String> getCellLatency(Event event) {
+        return getValueFromAdditionalMeasurement(event, "latency");
+    }
+
+    private Optional<String> getValueFromAdditionalMeasurement(Event event, String key) {
+        Optional<MeasurementFields.AdditionalMeasurement> measurement = getAdditionalMeasurement(event, key);
+        return measurement.map(this::getValueFromAdditionalMeasurement);
+    }
+
+    private String getValueFromAdditionalMeasurement(MeasurementFields.AdditionalMeasurement measurement) {
+        return measurement.getHashMap().get("value");
+    }
+
+    private Optional<MeasurementFields.AdditionalMeasurement> getAdditionalMeasurement(Event event,
+            String additionalMeasurement) {
+        return event.getMeasurementFields().getAdditionalMeasurements().stream()
+                       .filter(e -> e.getName().equals(additionalMeasurement)).findFirst();
+    }
+
+    private long addDelayTime(long epoch) {
+        return epoch + failingCheckoutDelayTimeInSec * TO_MICRO_SEC;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanEventCustomizerFactory.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanEventCustomizerFactory.java
new file mode 100644
index 0000000..3fbeda9
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanEventCustomizerFactory.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.text.MessageFormat;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.service.ue.RanUeHolder;
+import org.onap.a1pesimulator.service.ves.RanSendVesRunnable.EventCustomizer;
+import org.springframework.stereotype.Component;
+
+@Component
+public class RanEventCustomizerFactory {
+
+    private final EventCustomizer regularEventCustomizer;
+    private final RanUeHolder ranUeHolder;
+
+    public RanEventCustomizerFactory(EventCustomizer regularEventCustomizer, RanUeHolder ranUeHolder) {
+        this.ranUeHolder = ranUeHolder;
+        this.regularEventCustomizer = regularEventCustomizer;
+    }
+
+    public EventCustomizer getEventCustomizer(Event event, Mode mode) {
+        switch (mode) {
+            case REGULAR:
+                return regularEventCustomizer;
+            case FAILURE:
+                return new RanCellFailureEventCustomizer(event, ranUeHolder);
+            default:
+                throw new RuntimeException(
+                        MessageFormat.format("Cannot construct event customizer for mode: {0}", mode));
+        }
+    }
+
+    public enum Mode {
+        REGULAR, FAILURE
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanSendVesRunnable.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanSendVesRunnable.java
new file mode 100644
index 0000000..7378bc0
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanSendVesRunnable.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.util.Collection;
+import java.util.function.Function;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.exception.VesBrokerException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RanSendVesRunnable implements Runnable {
+
+    private static final Logger log = LoggerFactory.getLogger(RanSendVesRunnable.class);
+
+    private final RanVesSender vesSender;
+    private Event event;
+    private final EventCustomizer eventCustomizer;
+    private final Collection<OnEventAction> onEventAction;
+
+    public RanSendVesRunnable(RanVesSender vesSender, Event event, EventCustomizer eventCustomizer,
+            Collection<OnEventAction> onEventActions) {
+        this.vesSender = vesSender;
+        this.event = event;
+        this.eventCustomizer = eventCustomizer;
+        this.onEventAction = onEventActions;
+    }
+
+    @Override
+    public void run() {
+        try {
+            Event customizedEvent = eventCustomizer.apply(event);
+            onEventAction.forEach(action -> action.onEvent(customizedEvent));
+            vesSender.send(customizedEvent);
+        } catch (VesBrokerException e) {
+            log.error("Sending scheduled event failed: {}", e.getMessage());
+        }
+    }
+
+    public void updateEvent(Event event) {
+        this.event = event;
+    }
+
+    @FunctionalInterface
+    public interface EventCustomizer extends Function<Event, Event> { }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanVesBrokerService.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesBrokerService.java
new file mode 100644
index 0000000..8a90d46
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesBrokerService.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.RanPeriodicVesEvent;
+import org.springframework.http.ResponseEntity;
+
+public interface RanVesBrokerService {
+
+    ResponseEntity<String> startSendingVesEvents(String identifier, Event vesEvent, Integer interval);
+
+    Optional<RanPeriodicVesEvent> stopSendingVesEvents(String identifier);
+
+    Map<String, RanPeriodicVesEvent> getPeriodicEventsCache();
+
+    Collection<String> getEnabledEventElementIdentifiers();
+
+    Event getEventStructure(String identifier);
+
+    Event startSendingFailureVesEvents(String identifier);
+
+    Event getGlobalPmVesStructure();
+
+    void setGlobalPmVesStructure(Event event);
+
+    Integer getGlobalVesInterval();
+
+    void setGlobalVesInterval(Integer interval);
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanVesBrokerServiceImpl.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesBrokerServiceImpl.java
new file mode 100644
index 0000000..861bd36
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesBrokerServiceImpl.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.MeasurementFields.AdditionalMeasurement;
+import org.onap.a1pesimulator.data.ves.RanPeriodicVesEvent;
+import org.onap.a1pesimulator.util.Constants;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanVesBrokerServiceImpl implements RanVesBrokerService {
+
+    private final RanVesDataProvider vesDataProvider;
+
+    private final RanVesHolder vesHolder;
+
+    public RanVesBrokerServiceImpl(RanVesDataProvider vesDataProvider, RanVesHolder vesHolder) {
+        this.vesDataProvider = vesDataProvider;
+        this.vesHolder = vesHolder;
+    }
+
+    @Override
+    public Map<String, RanPeriodicVesEvent> getPeriodicEventsCache() {
+        return vesHolder.getPeriodicEventsCache();
+    }
+
+    @Override
+    public ResponseEntity<String> startSendingVesEvents(String identifier, Event vesEvent, Integer interval) {
+
+        enrichWithIdentifier(identifier, vesEvent);
+        vesHolder.startSendingVesEvents(identifier, vesEvent, interval);
+
+        return ResponseEntity.accepted().body("VES Event sending started");
+    }
+
+    @Override
+    public Event startSendingFailureVesEvents(String identifier) {
+
+        Event vesEvent = vesDataProvider.getFailurePmVesEvent();
+
+        enrichWithIdentifier(identifier, vesEvent);
+        vesHolder.startSendingFailureVesEvents(identifier, vesEvent);
+        return vesEvent;
+    }
+
+    @Override
+    public Optional<RanPeriodicVesEvent> stopSendingVesEvents(String identifier) {
+        return vesHolder.stopSendingVesEvents(identifier);
+    }
+
+    @Override
+    public Collection<String> getEnabledEventElementIdentifiers() {
+        return vesHolder.getEnabledEventElementIdentifiers();
+    }
+
+    @Override
+    public Event getEventStructure(String identifier) {
+        return vesHolder.getEventStructure(identifier);
+    }
+
+    @Override
+    public Event getGlobalPmVesStructure() {
+        return vesDataProvider.getPmVesEvent();
+    }
+
+    @Override
+    public void setGlobalPmVesStructure(Event event) {
+        vesDataProvider.setPmVesEvent(event);
+    }
+
+    @Override
+    public Integer getGlobalVesInterval() {
+        return vesDataProvider.getRegularVesInterval();
+    }
+
+    @Override
+    public void setGlobalVesInterval(Integer interval) {
+        vesDataProvider.setInterval(interval);
+    }
+
+    private void enrichWithIdentifier(String identifier, Event event) {
+        if (event.getMeasurementFields() == null || event.getMeasurementFields().getAdditionalMeasurements() == null) {
+            return;
+        }
+        Collection<AdditionalMeasurement> additionalMeasurements =
+                event.getMeasurementFields().getAdditionalMeasurements();
+        Optional<AdditionalMeasurement> identityOpt = additionalMeasurements.stream()
+                                                              .filter(m -> Constants.MEASUREMENT_FIELD_IDENTIFIER
+                                                                                   .equalsIgnoreCase(m.getName()))
+                                                              .findAny();
+        if (identityOpt.isPresent()) {
+            identityOpt.get().getHashMap().put(Constants.MEASUREMENT_FIELD_IDENTIFIER, identifier);
+        } else {
+            AdditionalMeasurement measurement = new AdditionalMeasurement();
+            measurement.setName(Constants.MEASUREMENT_FIELD_IDENTIFIER);
+            measurement.setHashMap(Collections.singletonMap(Constants.MEASUREMENT_FIELD_VALUE, identifier));
+            additionalMeasurements.add(measurement);
+        }
+    }
+
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanVesDataProvider.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesDataProvider.java
new file mode 100644
index 0000000..95743f3
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesDataProvider.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.io.IOException;
+import java.net.URL;
+import lombok.Setter;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.util.JsonUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanVesDataProvider {
+
+    private static final String PM_VES_LOCATION = "classpath:pmVes.json";
+    private static final String PM_FAILURE_VES_LOCATION = "classpath:failurePmVes.json";
+
+    @Setter
+    private Event pmVesEvent;
+    @Setter
+    private Event failurePmVesEvent;
+    @Setter
+    private Integer interval;
+
+    private final Integer defaultInterval;
+    private final ResourceLoader resourceLoader;
+
+    public RanVesDataProvider(@Value("${ves.defaultInterval}") Integer defaultInterval, ResourceLoader resourceLoader) {
+        this.defaultInterval = defaultInterval;
+        this.resourceLoader = resourceLoader;
+    }
+
+    @Cacheable("pmVes")
+    public Event loadPmVesEvent() {
+        URL resourceUrl = getResourceURL(resourceLoader.getResource(PM_VES_LOCATION));
+        return JsonUtils.INSTANCE.deserializeFromFileUrl(resourceUrl, Event.class);
+    }
+
+    @Cacheable("failurePmVes")
+    public Event loadFailurePmVesEvent() {
+        URL resourceUrl = getResourceURL(resourceLoader.getResource(PM_FAILURE_VES_LOCATION));
+        return JsonUtils.INSTANCE.deserializeFromFileUrl(resourceUrl, Event.class);
+    }
+
+    public Integer getRegularVesInterval() {
+        if (interval == null) {
+            return defaultInterval;
+        }
+        return interval;
+    }
+
+    public Integer getFailureVesInterval() {
+        return defaultInterval;
+    }
+
+    public Event getPmVesEvent() {
+        if (pmVesEvent == null) {
+            return loadPmVesEvent();
+        }
+        return pmVesEvent;
+    }
+
+    public Event getFailurePmVesEvent() {
+        if (failurePmVesEvent == null) {
+            return loadFailurePmVesEvent();
+        }
+        return failurePmVesEvent;
+    }
+
+    private URL getResourceURL(Resource resource) {
+        try {
+            return resource.getURL();
+        } catch (IOException e) {
+            throw new RuntimeException("Cannot get resource URL for: " + resource.getFilename());
+        }
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanVesHolder.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesHolder.java
new file mode 100644
index 0000000..d53d8dd
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesHolder.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import java.text.MessageFormat;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ScheduledFuture;
+import java.util.function.BiFunction;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.RanPeriodicVesEvent;
+import org.onap.a1pesimulator.service.ves.RanEventCustomizerFactory.Mode;
+import org.onap.a1pesimulator.service.ves.RanSendVesRunnable.EventCustomizer;
+import org.springframework.http.ResponseEntity;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RanVesHolder {
+
+    private final Map<String, RanPeriodicVesEvent> periodicEventsCache = new ConcurrentHashMap<>();
+
+    private final RanVesDataProvider vesDataProvider;
+    private final RanEventCustomizerFactory eventCustomizerFactory;
+    private final ThreadPoolTaskScheduler vesPmThreadPoolTaskScheduler;
+    private final Collection<OnEventAction> onEventActions;
+    private final RanVesSender vesSender;
+
+    public RanVesHolder(ThreadPoolTaskScheduler vesPmThreadPoolTaskScheduler, RanVesSender vesSender,
+            RanEventCustomizerFactory eventCustomizerFactory, RanVesDataProvider vesDataProvider,
+            Collection<OnEventAction> onEventActions) {
+        this.vesPmThreadPoolTaskScheduler = vesPmThreadPoolTaskScheduler;
+        this.vesSender = vesSender;
+        this.eventCustomizerFactory = eventCustomizerFactory;
+        this.vesDataProvider = vesDataProvider;
+        this.onEventActions = onEventActions;
+    }
+
+    Map<String, RanPeriodicVesEvent> getPeriodicEventsCache() {
+        return periodicEventsCache;
+    }
+
+    ResponseEntity<String> startSendingVesEvents(String identifier, Event vesEvent, Integer interval) {
+
+        periodicEventsCache.compute(identifier,
+                new ThreadCacheUpdateFunction(vesPmThreadPoolTaskScheduler, vesEvent, interval,
+                        eventCustomizerFactory.getEventCustomizer(vesEvent, Mode.REGULAR), onEventActions, vesSender));
+        return ResponseEntity.accepted().body("VES Event sending started");
+    }
+
+    ResponseEntity<String> startSendingFailureVesEvents(String identifier, Event vesEvent) {
+
+        periodicEventsCache.compute(identifier, new ThreadCacheUpdateFunction(vesPmThreadPoolTaskScheduler, vesEvent,
+                vesDataProvider.getFailureVesInterval(),
+                eventCustomizerFactory.getEventCustomizer(vesEvent, Mode.FAILURE), onEventActions, vesSender));
+        return ResponseEntity.accepted().body("Failure VES Event sending started");
+    }
+
+    Optional<RanPeriodicVesEvent> stopSendingVesEvents(String identifier) {
+        RanPeriodicVesEvent periodicEvent = periodicEventsCache.remove(identifier);
+        if (periodicEvent == null) {
+            return Optional.empty();
+        }
+        periodicEvent.getScheduledFuture().cancel(false);
+        return Optional.of(periodicEvent);
+    }
+
+    Collection<String> getEnabledEventElementIdentifiers() {
+        return periodicEventsCache.keySet();
+    }
+
+    public boolean isEventEnabled(String identifier) {
+        return periodicEventsCache.containsKey(identifier);
+    }
+
+    Event getEventStructure(String identifier) {
+        if (!periodicEventsCache.containsKey(identifier)) {
+            throw new IllegalArgumentException(
+                    MessageFormat.format("Cannot find event for given source {0}", identifier));
+        }
+        return periodicEventsCache.get(identifier).getEvent();
+    }
+
+    private static class ThreadCacheUpdateFunction
+            implements BiFunction<String, RanPeriodicVesEvent, RanPeriodicVesEvent> {
+
+        private final Integer interval;
+        private final ThreadPoolTaskScheduler vesPmThreadPoolTaskScheduler;
+        private final Event vesEvent;
+        private final EventCustomizer eventCustomizer;
+        private final Collection<OnEventAction> onEventActions;
+        private final RanVesSender vesSender;
+
+        public ThreadCacheUpdateFunction(ThreadPoolTaskScheduler vesPmThreadPoolTaskScheduler, Event vesEvent,
+                Integer interval, EventCustomizer eventCustomizer, Collection<OnEventAction> onEventActions,
+                RanVesSender vesSender) {
+            this.vesPmThreadPoolTaskScheduler = vesPmThreadPoolTaskScheduler;
+            this.vesEvent = vesEvent;
+            this.interval = interval;
+            this.eventCustomizer = eventCustomizer;
+            this.onEventActions = onEventActions;
+            this.vesSender = vesSender;
+        }
+
+        @Override
+        public RanPeriodicVesEvent apply(String key, RanPeriodicVesEvent value) {
+            if (value != null) {
+                // if thread is registered then cancel it and schedule a new one
+                value.getScheduledFuture().cancel(false);
+            }
+            RanSendVesRunnable sendVesRunnable =
+                    new RanSendVesRunnable(vesSender, vesEvent, eventCustomizer, onEventActions);
+            ScheduledFuture<?> scheduledFuture =
+                    vesPmThreadPoolTaskScheduler.scheduleAtFixedRate(sendVesRunnable, interval * 1000L);
+            return RanPeriodicVesEvent.builder().event(vesEvent).interval(interval).scheduledFuture(scheduledFuture)
+                           .sendVesRunnable(sendVesRunnable).build();
+        }
+
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/service/ves/RanVesSender.java b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesSender.java
new file mode 100644
index 0000000..9c50197
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/service/ves/RanVesSender.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.service.ves;
+
+import org.onap.a1pesimulator.data.VnfConfig;
+import org.onap.a1pesimulator.data.ves.CommonEventHeader;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.exception.VesBrokerException;
+import org.onap.a1pesimulator.util.JsonUtils;
+import org.onap.a1pesimulator.util.VnfConfigReader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+
+@Service
+public class RanVesSender {
+
+    private static final Logger log = LoggerFactory.getLogger(RanVesSender.class);
+
+    private RestTemplate restTemplate;
+
+    private String vesCollectorProtocol;
+
+    private String vesCollectorPath;
+
+    private VnfConfigReader vnfConfigReader;
+
+    public RanVesSender(RestTemplate restTemplate, VnfConfigReader vnfConfigReader,
+            @Value("${ves.collector.protocol}") String vesCollectorProtocol,
+            @Value("${ves.collector.endpoint}") String vesCollectorPath) {
+        this.restTemplate = restTemplate;
+        this.vnfConfigReader = vnfConfigReader;
+        this.vesCollectorProtocol = vesCollectorProtocol;
+        this.vesCollectorPath = vesCollectorPath;
+    }
+
+    public ResponseEntity<String> send(Event vesEvent) throws VesBrokerException {
+        VnfConfig vnfConfig = vnfConfigReader.getVnfConfig();
+        String url = getVesCollectorUrl(vnfConfig);
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        headers.setBasicAuth(vnfConfig.getVesUser(), vnfConfig.getVesPassword());
+
+        setVnfInfo(vesEvent, vnfConfig);
+        String event = JsonUtils.INSTANCE.objectToPrettyString(vesEvent);
+
+        log.info("Sending following VES event: {}", event);
+
+        HttpEntity<String> entity = new HttpEntity<>(event, headers);
+        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, entity, String.class);
+
+        log.debug("Response received: {}", response);
+
+        if (response.getStatusCode() == HttpStatus.OK || response.getStatusCode() == HttpStatus.ACCEPTED) {
+            return response;
+        } else {
+            String errorMsg =
+                    "Failed to send VES event to the collector with response status code:" + response.getStatusCode();
+            throw new VesBrokerException(errorMsg);
+        }
+    }
+
+    private String getVesCollectorUrl(VnfConfig vnfConfig) {
+        return vesCollectorProtocol + "://" + vnfConfig.getVesHost() + ":" + vnfConfig.getVesPort() + vesCollectorPath;
+    }
+
+    private void setVnfInfo(Event vesEvent, VnfConfig vnfConfig) {
+        CommonEventHeader header = vesEvent.getCommonEventHeader();
+        header.setSourceId(vnfConfig.getVnfId());
+        header.setSourceName(vnfConfig.getVnfName());
+        vesEvent.setCommonEventHeader(header);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/util/Constants.java b/src/main/java/org/onap/a1pesimulator/util/Constants.java
new file mode 100644
index 0000000..1964efd
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/util/Constants.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.util;
+
+public class Constants {
+
+    private Constants() {
+    }
+
+    public static final String MEASUREMENT_FIELD_IDENTIFIER = "identifier";
+    public static final String MEASUREMENT_FIELD_VALUE = "value";
+}
diff --git a/src/main/java/org/onap/a1pesimulator/util/DistanceCalculator.java b/src/main/java/org/onap/a1pesimulator/util/DistanceCalculator.java
new file mode 100644
index 0000000..e487ed3
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/util/DistanceCalculator.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.util;
+
+public class DistanceCalculator {
+
+    private static final int EARTH_RADIUS = 6371; // Earth radius in KM
+
+    private DistanceCalculator() {
+    }
+
+    /**
+     * Calculate distance in KM using Haversine formula
+     */
+    public static double calculate(double startLat, double startLong, double endLat, double endLong) {
+        return haversine(startLat, startLong, endLat, endLong);
+    }
+
+    public static boolean isInRange(double startLat, double startLong, double endLat, double endLong, double range) {
+        double distance = calculate(startLat, startLong, endLat, endLong);
+        return distance < range;
+    }
+
+    private static double haversine(double startLat, double startLong, double endLat, double endLong) {
+        double dLat = Math.toRadians(endLat - startLat);
+        double dLon = Math.toRadians(endLong - startLong);
+        double startLatInRadians = Math.toRadians(startLat);
+        double endLatInRadians = Math.toRadians(endLat);
+
+        double a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(startLatInRadians)
+                                                             * Math.cos(endLatInRadians);
+        double c = 2 * Math.asin(Math.sqrt(a));
+        return EARTH_RADIUS * c;
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/util/ItemsRefresher.java b/src/main/java/org/onap/a1pesimulator/util/ItemsRefresher.java
new file mode 100644
index 0000000..6991da0
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/util/ItemsRefresher.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.util;
+
+import org.onap.a1pesimulator.service.cell.RanCellsHolder;
+import org.onap.a1pesimulator.service.ue.RanUeHolder;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Service;
+
+@Service
+@EnableScheduling
+public class ItemsRefresher {
+
+    private final RanCellsHolder cellsHolder;
+    private final RanUeHolder ueHolder;
+
+    public ItemsRefresher(final RanCellsHolder cellsHolder, final RanUeHolder ueHolder) {
+        this.cellsHolder = cellsHolder;
+        this.ueHolder = ueHolder;
+    }
+
+    @Scheduled(fixedRateString = "${refresher.fixed.rate.ms}")
+    public void refresh() {
+        if (cellsHolder.hasChanged()) {
+            cellsHolder.refresh();
+        }
+
+        if (ueHolder.hasChanged()) {
+            ueHolder.refresh();
+        }
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/util/JsonUtils.java b/src/main/java/org/onap/a1pesimulator/util/JsonUtils.java
new file mode 100644
index 0000000..9263bc1
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/util/JsonUtils.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.util;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.URL;
+import java.text.MessageFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public enum JsonUtils {
+
+    INSTANCE;
+
+    private static final Logger log = LoggerFactory.getLogger(JsonUtils.class);
+
+    private ObjectMapper mapper;
+
+    private JsonUtils() {
+        this.mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+    }
+
+    public String objectToPrettyString(Object object) {
+        try {
+            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);
+        } catch (JsonProcessingException e) {
+            throw new JsonUtilsException("Cannot serialize object", e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> T clone(T object) {
+        String stringValue;
+        try {
+            stringValue = mapper.writeValueAsString(object);
+            return (T) mapper.readValue(stringValue, object.getClass());
+        } catch (JsonProcessingException e) {
+            throw new JsonUtilsException("Cannot clone object", e);
+        }
+    }
+
+    public <T> T deserializeFromFile(String fileName, Class<T> clazz) {
+        try {
+            return mapper.readValue(new FileReader(fileName), clazz);
+        } catch (IOException e) {
+            String errorMsg = MessageFormat.format("Could not deserialize from file: {0} into {1}", fileName,
+                    clazz.getSimpleName());
+            log.error(errorMsg, e);
+            throw new JsonUtilsException(errorMsg, e);
+        }
+    }
+
+    public <T> T deserializeFromFileUrl(URL url, Class<T> clazz) {
+        try {
+            return mapper.readValue(url, clazz);
+        } catch (IOException e) {
+            String errorMsg = MessageFormat.format("Could not deserialize from file URL: {0} into {1}", url,
+                    clazz.getSimpleName());
+            log.error(errorMsg, e);
+            throw new JsonUtilsException(errorMsg, e);
+        }
+    }
+
+    public <T> T deserialize(String string, Class<T> clazz) throws JsonUtilsException {
+        try {
+            return mapper.readValue(string, clazz);
+        } catch (IOException e) {
+            String errorMsg = MessageFormat
+                                      .format("Could not deserialize into {0} from object: {1}", clazz.getSimpleName(),
+                                              string);
+            log.error(errorMsg, e);
+            throw new JsonUtilsException(errorMsg, e);
+        }
+    }
+
+    public static class JsonUtilsException extends RuntimeException {
+
+        private static final long serialVersionUID = 1L;
+
+        public JsonUtilsException(String message, Throwable throwable) {
+            super(message, throwable);
+        }
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/util/RanVesUtils.java b/src/main/java/org/onap/a1pesimulator/util/RanVesUtils.java
new file mode 100644
index 0000000..d5f3e67
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/util/RanVesUtils.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.util;
+
+import java.text.MessageFormat;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.onap.a1pesimulator.data.ves.CommonEventHeader;
+import org.onap.a1pesimulator.data.ves.Event;
+import org.onap.a1pesimulator.data.ves.MeasurementFields.AdditionalMeasurement;
+import org.onap.a1pesimulator.service.ue.RanUeHolder;
+
+public class RanVesUtils {
+
+    private static final String PATTERN_DIGIT = "\\d+";
+    private static final String PATTERN_SPLIT_RANDOM = "-";
+    private static final String PATTERN_SPLIT_TRENDING = "->";
+    private static final String MARKER_START = "[[";
+    private static final String MARKER_END = "]]";
+    private static final String PATTERN_MARKER_START = "\\[\\[";
+    private static final String PATTERN_MARKER_END = "\\]\\]";
+
+    private static final String UE_PARAM_TRAFFIC_MODEL = "trafficModel";
+    private static final int TEN_MINUTES_MICROSECONDS = 10 * 60 * 1000_000;
+
+    private static final Random random = new Random();
+
+    private RanVesUtils() {
+    }
+
+    public static void updateHeader(Event event) {
+        CommonEventHeader commonEventHeader = event.getCommonEventHeader();
+        commonEventHeader.setLastEpochMicrosec(ChronoUnit.MICROS.between(Instant.EPOCH, Instant.now()));
+        commonEventHeader.setStartEpochMicrosec(getStartEpochMicroseconds());
+    }
+
+    public static AdditionalMeasurement buildTrafficModelMeasurement(AdditionalMeasurement identityMeasurement,
+            RanUeHolder ranUeHolder, String valuePattern) {
+        String cellId = identityMeasurement.getHashMap().get(Constants.MEASUREMENT_FIELD_VALUE);
+        AdditionalMeasurement trafficModel = new AdditionalMeasurement();
+        Map<String, String> hashMap = new HashMap<>();
+        trafficModel.setName(UE_PARAM_TRAFFIC_MODEL);
+        trafficModel.setHashMap(hashMap);
+        Collection<UserEquipment> cellUes = ranUeHolder.getUserEquipmentsConnectedToCell(cellId);
+        cellUes.stream().map(UserEquipment::getId).forEach(ueId -> hashMap.put(ueId, valuePattern));
+
+        return trafficModel;
+    }
+
+    public static List<AdditionalMeasurement> randomizeAdditionalMeasurements(
+            Collection<AdditionalMeasurement> toRandomize) {
+        return toRandomize.stream().map(measurement -> transformAdditionalMeasurementValues(measurement,
+                RanVesUtils::randomizeValue)).collect(Collectors.toList());
+    }
+
+    public static List<AdditionalMeasurement> setLowRangeValues(List<AdditionalMeasurement> toUpdateMeasurements) {
+        return toUpdateMeasurements.stream().map(measurement -> transformAdditionalMeasurementValues(measurement,
+                RanVesUtils::getLowRangeValue)).collect(Collectors.toList());
+    }
+
+    private static AdditionalMeasurement transformAdditionalMeasurementValues(AdditionalMeasurement measurement,
+            UnaryOperator<String> transformAction) {
+        AdditionalMeasurement randomizedMeasurement = new AdditionalMeasurement();
+        randomizedMeasurement.setName(measurement.getName());
+        randomizedMeasurement.setHashMap(transformValues(measurement.getHashMap(), transformAction));
+        return randomizedMeasurement;
+    }
+
+    private static Map<String, String> transformValues(Map<String, String> values,
+            UnaryOperator<String> transformAction) {
+        Map<String, String> randomizedMap = new HashMap<>(values.size());
+        values.forEach((key, value) -> randomizedMap.put(key, transformAction.apply(value)));
+        return randomizedMap;
+    }
+
+    private static String randomizeValue(String value) {
+        if (!isRange(value)) {
+            return value;
+        }
+        String toRandomize = value.substring(MARKER_START.length(), value.length() - MARKER_END.length());
+        String[] ranges = toRandomize.split(PATTERN_SPLIT_RANDOM);
+        int randomNumber = getRandomNumber(parseInt(ranges[0]), parseInt(ranges[1]));
+        return String.valueOf(randomNumber);
+    }
+
+    private static String getLowRangeValue(String value) {
+        if (!isRange(value)) {
+            return value;
+        }
+        String toRandomize = value.substring(MARKER_START.length(), value.length() - MARKER_END.length());
+        String[] ranges = toRandomize.split(PATTERN_SPLIT_RANDOM);
+        return String.valueOf(ranges[0]);
+    }
+
+    private static Long getStartEpochMicroseconds() {
+        long epochMicrosecondsNow = ChronoUnit.MICROS.between(Instant.EPOCH, Instant.now());
+        long lowest10minInterval = epochMicrosecondsNow - epochMicrosecondsNow % TEN_MINUTES_MICROSECONDS;
+        long highest10minInterval = lowest10minInterval + TEN_MINUTES_MICROSECONDS;
+
+        if ((epochMicrosecondsNow - lowest10minInterval) < (highest10minInterval - epochMicrosecondsNow)) {
+            return lowest10minInterval;
+        } else {
+            return highest10minInterval;
+        }
+    }
+
+    public static int getRandomNumber(int min, int max) {
+        return random.nextInt(max - min) + min;
+    }
+
+    private static int parseInt(String strNum) {
+        try {
+            return Integer.parseInt(strNum);
+        } catch (NumberFormatException nfe) {
+            throw new IllegalArgumentException(MessageFormat.format("Cannot parse int for value: {0}", strNum), nfe);
+        }
+    }
+
+    public static boolean isRange(String value) {
+        return value.startsWith(MARKER_START) && value.endsWith(MARKER_END);
+    }
+
+    private static boolean isRange(String value, String splitPattern) {
+        String pattern = PATTERN_MARKER_START + PATTERN_DIGIT + splitPattern + PATTERN_DIGIT + PATTERN_MARKER_END;
+        return value.matches(pattern);
+    }
+
+    public static boolean isRandomRange(String value) {
+        return isRange(value, PATTERN_SPLIT_RANDOM);
+    }
+
+    public static boolean isTrandingRange(String value) {
+        return isRange(value, PATTERN_SPLIT_TRENDING);
+    }
+
+    public static String[] splitRandomRange(String value) {
+        return splitRange(value, PATTERN_SPLIT_RANDOM);
+    }
+
+    public static String[] splitTrendingRange(String value) {
+        return splitRange(value, PATTERN_SPLIT_TRENDING);
+    }
+
+    private static String[] splitRange(String value, String splitPattern) {
+        String truncated = value.substring(MARKER_START.length(), value.length() - MARKER_END.length());
+        return truncated.split(splitPattern);
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/util/TopologyReader.java b/src/main/java/org/onap/a1pesimulator/util/TopologyReader.java
new file mode 100644
index 0000000..55e47cf
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/util/TopologyReader.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.util;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import org.onap.a1pesimulator.data.cell.CellList;
+import org.onap.a1pesimulator.data.ue.UserEquipment;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TopologyReader {
+
+    private final String topologyCellConfigFile;
+    private final String topologyUeConfigFile;
+
+    private long topologyCellLastModified = 0L;
+    private long topologyUeLastModified = 0L;
+
+    private TopologyReader(@Value("${topology.cell.config.file}") final String topologyCellConfigFile,
+            @Value("${topology.ue.config.file}") final String topologyUeConfigFile) {
+        this.topologyCellConfigFile = topologyCellConfigFile;
+        this.topologyUeConfigFile = topologyUeConfigFile;
+    }
+
+    public CellList loadCellTopology() {
+        final File file = new File(topologyCellConfigFile);
+        topologyCellLastModified = file.lastModified();
+
+        if (!file.exists()) {
+            return new CellList();
+        }
+
+        return JsonUtils.INSTANCE.deserializeFromFile(topologyCellConfigFile, CellList.class);
+    }
+
+    public Collection<UserEquipment> loadUeTopology() {
+        final File file = new File(topologyUeConfigFile);
+        topologyUeLastModified = file.lastModified();
+
+        if (!file.exists()) {
+            return Collections.emptyList();
+        }
+
+        final UserEquipment[] userEquipments =
+                JsonUtils.INSTANCE.deserializeFromFile(topologyUeConfigFile, UserEquipment[].class);
+        return Arrays.asList(userEquipments);
+    }
+
+    public boolean topologyCellHasChanged() {
+        return topologyCellLastModified != new File(topologyCellConfigFile).lastModified();
+    }
+
+    public boolean topologyUeHasChanged() {
+        return topologyUeLastModified != new File(topologyUeConfigFile).lastModified();
+    }
+}
diff --git a/src/main/java/org/onap/a1pesimulator/util/VnfConfigReader.java b/src/main/java/org/onap/a1pesimulator/util/VnfConfigReader.java
new file mode 100644
index 0000000..318b3d6
--- /dev/null
+++ b/src/main/java/org/onap/a1pesimulator/util/VnfConfigReader.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2021 Samsung Electronics
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package org.onap.a1pesimulator.util;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.Properties;
+import org.onap.a1pesimulator.data.VnfConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VnfConfigReader {
+
+    private static final Logger log = LoggerFactory.getLogger(VnfConfigReader.class);
+
+    private String vnfConfigFile;
+
+    private VnfConfigReader(@Value("${vnf.config.file}") String vnfConfigFile) {
+        this.vnfConfigFile = vnfConfigFile;
+    }
+
+    public VnfConfig getVnfConfig() {
+
+        Properties props = new Properties();
+        VnfConfig vnfConfig;
+
+        try {
+            props.load(new FileReader(vnfConfigFile));
+            ObjectMapper mapper = new ObjectMapper();
+            vnfConfig = mapper.convertValue(props, VnfConfig.class);
+        } catch (FileNotFoundException e) {
+            String errorMsg = "Could not find vnfConfigFile under: " + vnfConfigFile;
+            log.error(errorMsg);
+            throw new VnfConfigReaderException(errorMsg, e);
+        } catch (Exception e) {
+            String errorMsg = "Failed to get VnfConfig: " + e.getMessage();
+            log.error(errorMsg);
+            throw new VnfConfigReaderException(errorMsg, e);
+        }
+
+        return vnfConfig;
+    }
+
+    private static class VnfConfigReaderException extends RuntimeException {
+
+        private static final long serialVersionUID = 1L;
+
+        public VnfConfigReaderException(String message, Throwable t) {
+            super(message, t);
+        }
+    }
+}
diff --git a/src/main/resources/application-dev.properties b/src/main/resources/application-dev.properties
new file mode 100644
index 0000000..d8e142d
--- /dev/null
+++ b/src/main/resources/application-dev.properties
@@ -0,0 +1,17 @@
+#
+# Copyright (C) 2021 Samsung Electronics
+# 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
+#
+
+vnf.config.file=src/test/resources/vnf.config
+
+topology.cell.config.file=src/test/resources/cells.json
+topology.ue.config.file=src/test/resources/ue.json
\ No newline at end of file
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
new file mode 100644
index 0000000..b1f3a97
--- /dev/null
+++ b/src/main/resources/application.properties
@@ -0,0 +1,41 @@
+#
+# Copyright (C) 2021 Samsung Electronics
+# 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
+#
+
+server.port=9998
+vnf.config.file=/var/a1pesim/vnf.config
+ves.collector.protocol=https
+ves.collector.endpoint=/eventListener/v7
+ves.pm.maxPoolSize=10
+ves.defaultInterval=10
+ves.defaultFailureDuration=120
+
+ves.failing.throughput=1
+ves.failing.latency=500
+# in sec
+ves.failing.checkout.delay=15
+
+topology.cell.range=5
+topology.cell.config.file=/var/a1pesim/cells.json
+topology.ue.config.file=/var/a1pesim/ue.json
+
+spring.cache.cache-names=vnfConfig,pmVes,failurePmVes
+spring.cache.caffeine.spec=maximumSize=10,expireAfterAccess=900s
+
+spring.mvc.view.prefix: /
+spring.mvc.view.suffix: .jsp
+
+logging.config=classpath:logback-spring.xml
+
+refresher.fixed.rate.ms=60000
+
+restapi.version=v1
\ No newline at end of file
diff --git a/src/main/resources/failurePmVes.json b/src/main/resources/failurePmVes.json
new file mode 100644
index 0000000..1fdcdd3
--- /dev/null
+++ b/src/main/resources/failurePmVes.json
@@ -0,0 +1,41 @@
+{
+  "event": {
+    "commonEventHeader": {
+      "version": "4.0.1",
+      "vesEventListenerVersion": "7.0.1",
+      "domain": "measurement",
+      "eventName": "Measurement_vIsbcMmc",
+      "eventId": "measurement0000259",
+      "sequence": 3,
+      "priority": "Normal",
+      "reportingEntityId": "cc305d54-75b4-431b-adb2-eb6b9e541234",
+      "reportingEntityName": "ibcx0001vm002oam001",
+      "sourceId": "de305d54-75b4-431b-adb2-eb6b9e546014",
+      "sourceName": "ibcx0001vm002ssc001",
+      "nfVendorName": "Samsung",
+      "nfNamingCode": "ibcx",
+      "nfcNamingCode": "ssc",
+      "startEpochMicrosec": 1413378172000000,
+      "lastEpochMicrosec": 1413378172000000,
+      "timeZoneOffset": "UTC-05:30"
+    },
+    "measurementFields": {
+      "additionalMeasurements": [
+        {
+          "name": "latency",
+          "hashMap": {
+            "value": "[[200->500]]"
+          }
+        },
+        {
+          "name": "throughput",
+          "hashMap": {
+            "value": "[[10->1]]"
+          }
+        }
+      ],
+      "measurementInterval": 5,
+      "measurementFieldsVersion": "4.0"
+    }
+  }
+}
diff --git a/src/main/resources/logback-spring.xml b/src/main/resources/logback-spring.xml
new file mode 100644
index 0000000..f03b9bd
--- /dev/null
+++ b/src/main/resources/logback-spring.xml
@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Copyright (C) 2021 Samsung Electronics
+  ~ 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
+  -->
+
+<configuration>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <layout class="ch.qos.logback.classic.PatternLayout">
+            <Pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</Pattern>
+        </layout>
+    </appender>
+
+    <springProfile name="!dev">
+
+        <property name="LOG_DIR" value="${user.home}/log/${proc.name}"/>
+
+        <appender name="A1-PE-SIMULATOR-METRICS" class="ch.qos.logback.core.rolling.RollingFileAppender">
+            <filter class="ch.qos.logback.classic.filter.LevelFilter">
+                <level>INFO</level>
+                <onMatch>ACCEPT</onMatch>
+                <onMismatch>DENY</onMismatch>
+            </filter>
+            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+                <fileNamePattern>${LOG_DIR}/application/metrics-%d{yyyy-MM-dd}.%i.log.gz
+                </fileNamePattern>
+                <maxFileSize>30MB</maxFileSize>
+                <maxHistory>30</maxHistory>
+                <totalSizeCap>1GB</totalSizeCap>
+            </rollingPolicy>
+            <layout class="ch.qos.logback.classic.PatternLayout">
+                <pattern>%d{yyyy-MM-dd'T'HH:mm:ss.SSS+00:00}|NULL|%-5level:%class{36}:%M:%L: %m%n
+                </pattern>
+            </layout>
+        </appender>
+
+        <appender name="A1-PE-SIMULATOR-DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
+            <filter class="ch.qos.logback.classic.filter.LevelFilter">
+                <level>DEBUG</level>
+                <onMatch>ACCEPT</onMatch>
+                <onMismatch>DENY</onMismatch>
+            </filter>
+            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+                <fileNamePattern>${LOG_DIR}/application/debug-%d{yyyy-MM-dd}.%i.log.gz
+                </fileNamePattern>
+                <maxFileSize>30MB</maxFileSize>
+                <maxHistory>30</maxHistory>
+                <totalSizeCap>1GB</totalSizeCap>
+            </rollingPolicy>
+            <layout class="ch.qos.logback.classic.PatternLayout">
+                <pattern>%d{yyyy-MM-dd'T'HH:mm:ss.SSS+00:00}|NULL|%-5level:%class{36}:%M:%L: %m%n
+                </pattern>
+            </layout>
+        </appender>
+
+        <appender name="A1-PE-SIMULATOR-ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
+            <filter class="ch.qos.logback.classic.filter.LevelFilter">
+                <level>ERROR</level>
+                <onMatch>ACCEPT</onMatch>
+                <onMismatch>DENY</onMismatch>
+            </filter>
+            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+                <fileNamePattern>${LOG_DIR}/application/error-%d{yyyy-MM-dd}.%i.log.gz
+                </fileNamePattern>
+                <maxFileSize>30MB</maxFileSize>
+                <maxHistory>30</maxHistory>
+                <totalSizeCap>1GB</totalSizeCap>
+            </rollingPolicy>
+            <layout class="ch.qos.logback.classic.PatternLayout">
+                <pattern>%d{yyyy-MM-dd'T'HH:mm:ss.SSS+00:00}|NULL|%-5level:%class{36}:%M:%L: %m%n
+                </pattern>
+            </layout>
+        </appender>
+
+        <appender name="debugAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
+            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+                <fileNamePattern>${LOG_DIR}/debug-%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
+                <maxFileSize>30MB</maxFileSize>
+                <maxHistory>30</maxHistory>
+                <totalSizeCap>1GB</totalSizeCap>
+            </rollingPolicy>
+            <layout class="ch.qos.logback.classic.PatternLayout">
+                <pattern>%d{yyyy-MM-dd'T'HH:mm:ss.SSS+00:00}|NULL|%-5level:%class{36}:%M:%L: %m%n
+                </pattern>
+            </layout>
+        </appender>
+
+        <logger name="org.onap.a1pesimulator" level="debug" additivity="false">
+            <appender-ref ref="A1-PE-SIMULATOR-DEBUG"/>
+            <appender-ref ref="A1-PE-SIMULATOR-METRICS"/>
+            <appender-ref ref="A1-PE-SIMULATOR-ERROR"/>
+        </logger>
+
+        <root level="INFO">
+            <appender-ref ref="debugAppender"/>
+        </root>
+
+    </springProfile>
+
+    <springProfile name="dev">
+        <root level="INFO">
+            <appender-ref ref="STDOUT"/>
+        </root>
+    </springProfile>
+
+</configuration>
diff --git a/src/main/resources/pmVes.json b/src/main/resources/pmVes.json
new file mode 100644
index 0000000..9c4f717
--- /dev/null
+++ b/src/main/resources/pmVes.json
@@ -0,0 +1,41 @@
+{
+  "event": {
+    "commonEventHeader": {
+      "version": "4.0.1",
+      "vesEventListenerVersion": "7.0.1",
+      "domain": "measurement",
+      "eventName": "Measurement_vIsbcMmc",
+      "eventId": "measurement0000259",
+      "sequence": 3,
+      "priority": "Normal",
+      "reportingEntityId": "cc305d54-75b4-431b-adb2-eb6b9e541234",
+      "reportingEntityName": "ibcx0001vm002oam001",
+      "sourceId": "de305d54-75b4-431b-adb2-eb6b9e546014",
+      "sourceName": "ibcx0001vm002ssc001",
+      "nfVendorName": "Samsung",
+      "nfNamingCode": "ibcx",
+      "nfcNamingCode": "ssc",
+      "startEpochMicrosec": 1413378172000000,
+      "lastEpochMicrosec": 1413378172000000,
+      "timeZoneOffset": "UTC-05:30"
+    },
+    "measurementFields": {
+      "additionalMeasurements": [
+        {
+          "name": "latency",
+          "hashMap": {
+            "value": "[[10-150]]"
+          }
+        },
+        {
+          "name": "throughput",
+          "hashMap": {
+            "value": "[[10-100]]"
+          }
+        }
+      ],
+      "measurementInterval": 5,
+      "measurementFieldsVersion": "4.0"
+    }
+  }
+}