From 57db17f6367b30d6575a0c1ef48c93c041a80213 Mon Sep 17 00:00:00 2001
From: "ankur.ankur" <ankur.ankur@virtana.com>
Date: Wed, 4 Jun 2025 12:05:33 +0530
Subject: [PATCH] Virtana Pack Added

---
 virtana_pack/actions/echo_alert.py            |   6 +
 virtana_pack/actions/echo_alert.yaml          |  12 ++
 virtana_pack/actions/restart_vm.py            |  55 +++++
 virtana_pack/actions/restart_vm.yaml          |  18 ++
 virtana_pack/ansible/restart_vm.yml           |  97 +++++++++
 virtana_pack/icon.png                         | Bin 0 -> 2992 bytes
 virtana_pack/pack.yaml                        |  13 ++
 virtana_pack/requirements.txt                 |   4 +
 .../sensors/action_execution_polling.py       |  46 +++++
 .../sensors/action_execution_polling.yaml     |   5 +
 virtana_pack/sensors/action_status_polling.py |  46 +++++
 .../sensors/action_status_polling.yaml        |   5 +
 virtana_pack/sensors/lib/__init__.py          |   0
 virtana_pack/sensors/lib/action_executor.py   | 193 ++++++++++++++++++
 .../sensors/lib/action_status_notifier.py     | 125 ++++++++++++
 virtana_pack/sensors/lib/auth_helper.py       |  34 +++
 .../sensors/lib/create_action_definitions.py  |  91 +++++++++
 virtana_pack/sensors/lib/disable_sensor.py    |  39 ++++
 virtana_pack/sensors/lib/list_actions.py      | 133 ++++++++++++
 virtana_pack/sensors/lib/mongo_helper.py      | 111 ++++++++++
 .../lib/update_and_cleanup_executions.py      |  46 +++++
 virtana_pack/sensors/setup_sensor.py          |  56 +++++
 virtana_pack/sensors/setup_sensor.yaml        |   5 +
 23 files changed, 1140 insertions(+)
 create mode 100644 virtana_pack/actions/echo_alert.py
 create mode 100644 virtana_pack/actions/echo_alert.yaml
 create mode 100644 virtana_pack/actions/restart_vm.py
 create mode 100644 virtana_pack/actions/restart_vm.yaml
 create mode 100644 virtana_pack/ansible/restart_vm.yml
 create mode 100644 virtana_pack/icon.png
 create mode 100755 virtana_pack/pack.yaml
 create mode 100755 virtana_pack/requirements.txt
 create mode 100644 virtana_pack/sensors/action_execution_polling.py
 create mode 100644 virtana_pack/sensors/action_execution_polling.yaml
 create mode 100644 virtana_pack/sensors/action_status_polling.py
 create mode 100644 virtana_pack/sensors/action_status_polling.yaml
 create mode 100644 virtana_pack/sensors/lib/__init__.py
 create mode 100644 virtana_pack/sensors/lib/action_executor.py
 create mode 100644 virtana_pack/sensors/lib/action_status_notifier.py
 create mode 100644 virtana_pack/sensors/lib/auth_helper.py
 create mode 100644 virtana_pack/sensors/lib/create_action_definitions.py
 create mode 100644 virtana_pack/sensors/lib/disable_sensor.py
 create mode 100644 virtana_pack/sensors/lib/list_actions.py
 create mode 100644 virtana_pack/sensors/lib/mongo_helper.py
 create mode 100644 virtana_pack/sensors/lib/update_and_cleanup_executions.py
 create mode 100644 virtana_pack/sensors/setup_sensor.py
 create mode 100644 virtana_pack/sensors/setup_sensor.yaml

diff --git a/virtana_pack/actions/echo_alert.py b/virtana_pack/actions/echo_alert.py
new file mode 100644
index 00000000..6abee6c1
--- /dev/null
+++ b/virtana_pack/actions/echo_alert.py
@@ -0,0 +1,6 @@
+from st2common.runners.base_action import Action
+
+class EchoAlertAction(Action):
+    def run(self, text):
+        self.logger.info(f"Echo alert received: {text}")
+        return text
diff --git a/virtana_pack/actions/echo_alert.yaml b/virtana_pack/actions/echo_alert.yaml
new file mode 100644
index 00000000..a98b11db
--- /dev/null
+++ b/virtana_pack/actions/echo_alert.yaml
@@ -0,0 +1,12 @@
+name: "echo_alert"
+description: "Echoes the input text"
+runner_type: "python-script"
+entry_point: "echo_alert.py"
+enabled: true
+parameters:
+  text:
+    type: "string"
+    required: true
+    description: "Text message to echo"
+tags:
+  - name: "dev"
\ No newline at end of file
diff --git a/virtana_pack/actions/restart_vm.py b/virtana_pack/actions/restart_vm.py
new file mode 100644
index 00000000..54701863
--- /dev/null
+++ b/virtana_pack/actions/restart_vm.py
@@ -0,0 +1,55 @@
+import ansible_runner
+from st2common.runners.base_action import Action
+
+
+class RestartVMAction(Action):
+    def run(self, vcenter_hostname, vm_name):
+        try:
+            # Validate both parameters are provided as strings
+            if not vcenter_hostname or not isinstance(vcenter_hostname, str):
+                raise ValueError("vcenter_hostname must be a non-empty string.")
+
+            if not vm_name or not isinstance(vm_name, str):
+                raise ValueError("vm_name must be a non-empty string.")
+
+            # Retrieve credentials from stackstorm datastore
+            vcenter_username = self.action_service.get_value('vcenter.username', decrypt=True, local=False)
+            vcenter_password = self.action_service.get_value('vcenter.password', decrypt=True, local=False)
+
+            if not vcenter_username or not vcenter_password:
+                raise Exception("vCenter credentials are missing in the datastore.")
+
+            # Prepare the extra variables for the Ansible playbook
+            extra_vars = {
+                "vcenter_hostname": vcenter_hostname,
+                "vcenter_username": vcenter_username,
+                "vcenter_password": vcenter_password,
+                "vm_name": vm_name,
+                "validate_certs": False
+            }
+
+            # Path to the Ansible playbook
+            playbook_path = '/opt/stackstorm/packs/virtana_pack/ansible/restart_vm.yml'
+
+            # Run the Ansible playbook using the provided credentials and parameters
+            runner = ansible_runner.run(
+                private_data_dir='.',
+                playbook=playbook_path,
+                extravars=extra_vars
+            )
+
+            # Check the result of the playbook execution
+            if runner.status == "failed":
+                raise Exception(f"Ansible playbook failed with status: {runner.status}")
+
+            # Return the result of the operation
+            return {
+                "status": "VM restarted successfully",
+                "vm_name": vm_name,
+                "vcenter": vcenter_hostname,
+                "ansible_result": runner.stats
+            }
+
+        except Exception as e:
+            # Raise exception
+            raise
diff --git a/virtana_pack/actions/restart_vm.yaml b/virtana_pack/actions/restart_vm.yaml
new file mode 100644
index 00000000..1e94cb55
--- /dev/null
+++ b/virtana_pack/actions/restart_vm.yaml
@@ -0,0 +1,18 @@
+name: "restart_vm"
+runner_type: "python-script"
+description: "Restart a VM in vSphere based on vcenter_hostname and vm_name inputs"
+enabled: true
+entry_point: "restart_vm.py"
+
+parameters:
+  vcenter_hostname:
+    type: "string"
+    required: true
+    description: "vCenter hostname (e.g., vcenter.example.com)"
+
+  vm_name:
+    type: "string"
+    required: true
+    description: "Name of the VM to restart"
+tags:
+  - name: "dev"
\ No newline at end of file
diff --git a/virtana_pack/ansible/restart_vm.yml b/virtana_pack/ansible/restart_vm.yml
new file mode 100644
index 00000000..71364835
--- /dev/null
+++ b/virtana_pack/ansible/restart_vm.yml
@@ -0,0 +1,97 @@
+- name: Restart VM
+  hosts: localhost
+  gather_facts: no
+  collections:
+    - community.vmware
+
+  tasks:
+
+    # Authenticate with vCenter using REST API
+    - name: Authenticate with vCenter
+      uri:
+        url: "https://{{ vcenter_hostname }}/rest/com/vmware/cis/session"
+        method: POST
+        user: "{{ vcenter_username }}"
+        password: "{{ vcenter_password }}"
+        force_basic_auth: yes
+        validate_certs: "{{ validate_certs }}"
+        status_code: 200
+        return_content: yes
+      register: login_response
+      no_log: true
+
+    # Save the session token returned from authentication
+    - name: Save session token
+      set_fact:
+        session_token: "{{ login_response.json.value }}"
+
+    # Fetch list of all VMs from vCenter
+    - name: Get list of VMs
+      uri:
+        url: "https://{{ vcenter_hostname }}/rest/vcenter/vm"
+        method: GET
+        headers:
+          vmware-api-session-id: "{{ session_token }}"
+        validate_certs: "{{ validate_certs }}"
+        status_code: 200
+      register: vm_list
+      no_log: true
+
+    # Identify VM ID by matching VM name
+    - name: Find VM ID by name
+      set_fact:
+        vm_id: "{{ item.vm }}"
+      loop: "{{ vm_list.json.value }}"
+      when: item.name == vm_name
+
+    # Fail the play if VM not found
+    - name: Fail if VM not found
+      fail:
+        msg: "VM not found."
+      when: vm_id is not defined
+
+    # Power off the VM
+    - name: Stop VM
+      uri:
+        url: "https://{{ vcenter_hostname }}/rest/vcenter/vm/{{ vm_id }}/power/stop"
+        method: POST
+        headers:
+          vmware-api-session-id: "{{ session_token }}"
+        validate_certs: "{{ validate_certs }}"
+        status_code: 200
+        timeout: 60
+      register: stop_result
+
+    # Wait until the VM is fully powered off
+    - name: Wait for power off
+      uri:
+        url: "https://{{ vcenter_hostname }}/rest/vcenter/vm/{{ vm_id }}/power"
+        method: GET
+        headers:
+          vmware-api-session-id: "{{ session_token }}"
+        validate_certs: "{{ validate_certs }}"
+      register: power_status
+      until: power_status.json.value.state == "POWERED_OFF"
+      retries: 10
+      delay: 10
+      no_log: true
+
+    # Power on the VM again
+    - name: Start VM
+      uri:
+        url: "https://{{ vcenter_hostname }}/rest/vcenter/vm/{{ vm_id }}/power/start"
+        method: POST
+        headers:
+          vmware-api-session-id: "{{ session_token }}"
+        validate_certs: "{{ validate_certs }}"
+        status_code: 200
+        timeout: 60
+      register: start_result
+      retries: 5
+      delay: 10
+      until: start_result.status == 200
+
+    # Output final message on success
+    - name: Print result
+      debug:
+        msg: "VM restarted successfully."
diff --git a/virtana_pack/icon.png b/virtana_pack/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..d473f655d017efb1ef4423cc30127296b0c602a2
GIT binary patch
literal 2992
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

literal 0
HcmV?d00001

diff --git a/virtana_pack/pack.yaml b/virtana_pack/pack.yaml
new file mode 100755
index 00000000..191d981a
--- /dev/null
+++ b/virtana_pack/pack.yaml
@@ -0,0 +1,13 @@
+---
+ref: virtana_pack
+name: "Virtana Platform Pack"
+description: "Register Remote Stackstorm to Virtana Platform"
+keywords:
+  - StackStorm
+  - Global View
+  - Actions
+version: "1.0.1"
+author: "Virtana"
+email: "support@virtana.com"
+python_versions:
+  - "3"
diff --git a/virtana_pack/requirements.txt b/virtana_pack/requirements.txt
new file mode 100755
index 00000000..9dc63cbd
--- /dev/null
+++ b/virtana_pack/requirements.txt
@@ -0,0 +1,4 @@
+requests
+ansible
+ansible-runner
+pyvmomi
\ No newline at end of file
diff --git a/virtana_pack/sensors/action_execution_polling.py b/virtana_pack/sensors/action_execution_polling.py
new file mode 100644
index 00000000..a01a60bb
--- /dev/null
+++ b/virtana_pack/sensors/action_execution_polling.py
@@ -0,0 +1,46 @@
+import logging
+from st2reactor.sensor.base import PollingSensor
+from lib.action_executor import process_queued_actions
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class ActionExecutionPolling(PollingSensor):
+    def __init__(self, sensor_service, config=None, poll_interval=30):
+        super(ActionExecutionPolling, self).__init__(sensor_service=sensor_service,
+                                                     config=config,
+                                                     poll_interval=poll_interval)
+        self.pack_name = config.get("pack_name", "virtana_pack")
+        self.sensor_name = self.__class__.__name__
+
+    def setup(self):
+        """Called when the sensor starts."""
+        logger.info(f"Sensor '{self.sensor_name}' for '{self.pack_name}' is initialized.")
+
+    def poll(self):
+        """Runs at defined intervals and calls process_queued_actions()."""
+        logger.info("Polling for queued actions...")
+        success, results = process_queued_actions(self.config)
+
+        if success:
+            logger.info(f"Processed queued actions successfully: {results}")
+        else:
+            logger.error(f"Failed to process queued actions: {results}")
+
+    def cleanup(self):
+        """Called when the sensor stops."""
+        logger.info("Cleaning up ActionExecutionPolling")
+
+    def add_trigger(self, trigger):
+        """Called when a trigger is added."""
+        logger.info(f"Trigger added: {trigger}")
+
+    def update_trigger(self, trigger):
+        """Called when an existing trigger is updated."""
+        logger.info(f"Trigger updated: {trigger}")
+
+    def remove_trigger(self, trigger):
+        """Called when a trigger is removed."""
+        logger.info(f"Trigger removed: {trigger}")
diff --git a/virtana_pack/sensors/action_execution_polling.yaml b/virtana_pack/sensors/action_execution_polling.yaml
new file mode 100644
index 00000000..bd06fbec
--- /dev/null
+++ b/virtana_pack/sensors/action_execution_polling.yaml
@@ -0,0 +1,5 @@
+class_name: "ActionExecutionPolling"
+entry_point: "action_execution_polling.py"
+description: "A sensor that polls queued actions for executions from VP platform at defined intervals."
+poll_interval: 20
+enabled: true
diff --git a/virtana_pack/sensors/action_status_polling.py b/virtana_pack/sensors/action_status_polling.py
new file mode 100644
index 00000000..1d0a4f46
--- /dev/null
+++ b/virtana_pack/sensors/action_status_polling.py
@@ -0,0 +1,46 @@
+import logging
+from st2reactor.sensor.base import PollingSensor
+from lib.update_and_cleanup_executions import update_and_cleanup_executions
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class ActionStatusPolling(PollingSensor):
+    def __init__(self, sensor_service, config=None, poll_interval=30):
+        super(ActionStatusPolling, self).__init__(sensor_service=sensor_service,
+                                                     config=config,
+                                                     poll_interval=poll_interval)
+        self.pack_name = config.get("pack_name", "virtana_pack")
+        self.sensor_name = self.__class__.__name__
+
+    def setup(self):
+        """Called when the sensor starts."""
+        logger.info(f"Sensor '{self.sensor_name}' for '{self.pack_name}' is initialized.")
+
+    def poll(self):
+        """Runs at defined intervals and calls process_queued_actions()."""
+        logger.info("Polling for queued actions statuses...")
+        success, results = update_and_cleanup_executions(self.config)
+
+        if success:
+            logger.info(f"Processed queued actions successfully: {results}")
+        else:
+            logger.error(f"Failed to process queued actions: {results}")
+
+    def cleanup(self):
+        """Called when the sensor stops."""
+        logger.info("Cleaning up ActionStatusPolling")
+
+    def add_trigger(self, trigger):
+        """Called when a trigger is added."""
+        logger.info(f"Trigger added: {trigger}")
+
+    def update_trigger(self, trigger):
+        """Called when an existing trigger is updated."""
+        logger.info(f"Trigger updated: {trigger}")
+
+    def remove_trigger(self, trigger):
+        """Called when a trigger is removed."""
+        logger.info(f"Trigger removed: {trigger}")
diff --git a/virtana_pack/sensors/action_status_polling.yaml b/virtana_pack/sensors/action_status_polling.yaml
new file mode 100644
index 00000000..19a2519b
--- /dev/null
+++ b/virtana_pack/sensors/action_status_polling.yaml
@@ -0,0 +1,5 @@
+class_name: "ActionStatusPolling"
+entry_point: "action_status_polling.py"
+description: "A sensor that polls actions status submitted for executions from VP platform at defined intervals."
+poll_interval: 20
+enabled: true
diff --git a/virtana_pack/sensors/lib/__init__.py b/virtana_pack/sensors/lib/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/virtana_pack/sensors/lib/action_executor.py b/virtana_pack/sensors/lib/action_executor.py
new file mode 100644
index 00000000..9996049a
--- /dev/null
+++ b/virtana_pack/sensors/lib/action_executor.py
@@ -0,0 +1,193 @@
+import logging
+import requests
+
+from lib.auth_helper import AuthHelper
+from lib.mongo_helper import MongoHelper
+from lib.action_status_notifier import ActionStatusNotifier
+from st2client.client import Client
+from st2client.models import LiveAction
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def process_queued_actions(config):
+    """
+    Main function to process queued actions.
+    - Retrieves OAuth token.
+    - Fetches queued actions from API.
+    - Executes StackStorm actions.
+    - Saves execution details to MongoDB.
+    """
+    logger.info("Starting queued action processing...")
+    st2_client = Client()
+
+    token = get_oauth_token(config)
+    if not token:
+        return False, {"error": "OAuth token retrieval failed"}
+
+    actions_to_execute = fetch_queued_actions(config, token)
+    if not actions_to_execute:
+        logger.info("No queued actions found. Polling will continue.")
+        return True, {"message": "No actions to process"}
+
+    results, error_occurred = execute_actions(st2_client, config, actions_to_execute)
+
+    return (False, results) if error_occurred else (True, results)
+
+
+def get_oauth_token(config):
+    """
+    Retrieve OAuth token using AuthHelper.
+    """
+    try:
+        auth_helper = AuthHelper(config)
+        token = auth_helper.get_oauth_token()
+        if not token:
+            logger.error("OAuth token retrieval failed.")
+            return None
+        logger.debug(f"Retrieved OAuth token: {token[:30]}... (truncated for security)")
+        return token
+    except Exception as e:
+        logger.error("Error retrieving OAuth token.", exc_info=True)
+        return None
+
+
+def fetch_queued_actions(config, token):
+    """
+    Fetch queued actions from the external API.
+    """
+    base_url = config.get("base_url")
+    provider_id = config.get("provider_data", {}).get("providerId")
+
+    if not base_url or not provider_id:
+        logger.error("Missing required configurations: base_url or providerId.")
+        return None
+
+    request_url = f"{base_url}/api/actions/executions/queuedActions"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    query_params = {"providerId": provider_id}
+
+    try:
+        response = requests.get(request_url, headers=headers, params=query_params, verify=False, timeout=15)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to fetch queued actions: {str(e)}")
+        return None
+
+
+def execute_actions(st2_client, config, actions_to_execute):
+    """
+    Iterates over queued actions, executes them, and saves results.
+    """
+    results = []
+    error_occurred = False
+
+    for request in actions_to_execute:
+        action_execution_id = request.get("executionId")
+        external_ref = request.get("externalUrl")
+        action_params = request.get("actionParameters", [])
+
+        if not external_ref:
+            logger.error(f"Skipping action execution ID {action_execution_id}: Missing external ref.")
+            error_occurred = True
+            continue
+
+        try:
+            packname, actionname = external_ref.split('.')
+        except ValueError:
+            logger.error(f"Invalid external_ref format: {external_ref}")
+            error_occurred = True
+            continue
+
+        param_dict = {param["key"]: param["value"] for param in action_params}
+
+        logger.info(f"Executing StackStorm action: {packname}.{actionname} with params {param_dict}")
+
+        execution_id, status, error = execute_stackstorm_action(st2_client, external_ref, param_dict)
+        if execution_id:
+            save_to_mongo(config, action_execution_id, execution_id, status)
+            acknowledge(config, action_execution_id, "ACCEPTED")
+            results.append({"action_execution_id": action_execution_id, "execution_id": execution_id, "status": status})
+
+        else:
+            error_occurred = True
+            logger.info(
+                f"Error occurred while executing StackStorm action: {packname}.{actionname} with params {param_dict}")
+            result = {"result": str(error)}
+            acknowledgeWithResult(config, action_execution_id, "FAILED", result)
+
+    return results, error_occurred
+
+
+def execute_stackstorm_action(st2_client, action_ref, parameters):
+    """
+    Executes a StackStorm action and returns execution ID & status.
+    """
+    try:
+        live_action = LiveAction(action=action_ref, parameters=parameters)
+        execution = st2_client.executions.create(live_action)
+        logger.info(f"Executed StackStorm action: {action_ref}, Execution ID: {execution.id}")
+        return execution.id, execution.status, None
+    except Exception as e:
+        logger.error(f"Failed to execute action {action_ref}: {str(e)}")
+        return None, None, e
+
+
+def save_to_mongo(config, action_execution_id, execution_id, status):
+    """
+    Saves execution details to MongoDB.
+    """
+    try:
+        mongo_helper = MongoHelper(config)
+        mongo_helper.save_execution(action_execution_id, execution_id, status)
+        logger.info(f"Saved execution {execution_id} to MongoDB.")
+    except Exception as e:
+        logger.error(f"Failed to save execution to MongoDB: {str(e)}")
+
+
+def acknowledge(config, action_execution_ids, status):
+    """
+    Acknowledge one or more action executions to Cloud.
+
+    :param status: The acknowledgement status to send to Cloud.
+    :param config: StackStorm configuration
+    :param action_execution_ids: Single or list of action_execution_ids to acknowledge
+    """
+    try:
+        action_status_notifier = ActionStatusNotifier(config)
+
+        # Ensure it's a list to handle bulk processing
+        if not isinstance(action_execution_ids, list):
+            action_execution_ids = [action_execution_ids]
+
+        action_status_notifier.acknowledge_execution_update(action_execution_ids, status)
+        logger.info(f"Acknowledged action_execution_ids {action_execution_ids} to Cloud.")
+    except Exception as e:
+        logger.error(f"Failed to acknowledge action execution(s) to Cloud: {str(e)}")
+
+
+def acknowledgeWithResult(config, action_execution_ids, status, result):
+    """
+    Acknowledge one or more action executions to Cloud.
+
+    :param status: The acknowledgement status to send to Cloud.
+    :param config: StackStorm configuration
+    :param action_execution_ids: Single or list of action_execution_ids to acknowledge
+    """
+    try:
+        action_status_notifier = ActionStatusNotifier(config)
+
+        # Ensure it's a list to handle bulk processing
+        if not isinstance(action_execution_ids, list):
+            action_execution_ids = [action_execution_ids]
+
+        action_status_notifier.acknowledge_execution_update_with_result(action_execution_ids, status, result)
+        logger.info(f"Acknowledged action_execution_ids {action_execution_ids} to Cloud.")
+    except Exception as e:
+        logger.error(f"Failed to acknowledge action execution(s) to Cloud: {str(e)}")
diff --git a/virtana_pack/sensors/lib/action_status_notifier.py b/virtana_pack/sensors/lib/action_status_notifier.py
new file mode 100644
index 00000000..24db5a81
--- /dev/null
+++ b/virtana_pack/sensors/lib/action_status_notifier.py
@@ -0,0 +1,125 @@
+import requests
+import logging
+
+from st2client.client import Client
+from lib.auth_helper import AuthHelper
+from lib.mongo_helper import MongoHelper
+from datetime import datetime
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+class ActionStatusNotifier:
+    def __init__(self, config):
+        self.config = config
+        self.st2_client = Client()
+        self.auth_helper = AuthHelper(config)
+        self.mongo_helper = MongoHelper(config)
+        self.base_url = config.get('base_url')
+        self.update_url = f"{self.base_url}/api/actions/executions/status"
+
+    def _get_auth_headers(self):
+        token = self.auth_helper.get_oauth_token()
+        if not token:
+            logger.error("Failed to retrieve OAuth token.")
+            return None
+        return {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+
+    def _send_request(self, payloads):
+        try:
+            headers = self._get_auth_headers()
+            if not headers:
+                return False, {"error": "OAuth token retrieval failed"}
+
+            if not isinstance(payloads, list):
+                payloads = [payloads]  # Ensure payloads is a list for bulk processing
+
+            response = requests.post(self.update_url, json=payloads, headers=headers, verify=False, timeout=15)
+            response.raise_for_status()
+
+            logger.info(f"Request sent successfully: {response.json()}")
+            return True, response.json()
+
+        except requests.exceptions.RequestException as req_err:
+            logger.error(f"Request error: {str(req_err)}")
+            return False, str(req_err)
+
+        except Exception as e:
+            logger.error(f"Unexpected error: {str(e)}")
+            return False, str(e)
+
+    def send_execution_update(self, execution_ids):
+        if not isinstance(execution_ids, list):
+            execution_ids = [execution_ids]
+
+        payloads = []
+        completed_statuses = {"SUCCEEDED", "FAILED", "CANCELED"}  # StackStorm completed statuses
+        completed_execution_ids = []  # To store completed execution IDs
+        for execution_id in execution_ids:
+            record = self.mongo_helper.find_execution_by_id(execution_id)
+            if not record:
+                logger.error(f"No matching record found for execution_id: {execution_id}")
+                continue
+
+            action_execution_id = record.get("action_execution_id", "Unknown")
+            execution = self.st2_client.executions.get_by_id(execution_id)
+            if not execution:
+                logger.error(f"No execution details found for execution_id: {execution_id}")
+                continue
+
+            # Check if execution is in a completed state
+            if execution.status.upper() in completed_statuses:
+                completed_execution_ids.append(execution_id)
+
+            payloads.append({
+                "action_execution_id": action_execution_id,
+                "external_execution_id": execution_id,
+                "status": execution.status,
+                "end_timestamp": getattr(execution, "end_timestamp", "No end_timestamp available"),
+                "log": getattr(execution, "log", "No log available"),
+                "result": getattr(execution, "result", "No result available")
+            })
+        if payloads:
+            success, _ = self._send_request(payloads)
+            return success, completed_execution_ids
+        else:
+            logger.warning("[WARNING] No valid executions found for update.")
+            return False, []
+
+    def acknowledge_execution_update(self, action_execution_ids, status):
+        if not isinstance(action_execution_ids, list):
+            action_execution_ids = [action_execution_ids]
+
+        payloads = [{"action_execution_id": aid, "status": status} for aid in action_execution_ids]
+        return self._send_request(payloads)
+
+    def acknowledge_execution_update_with_result(self, action_execution_ids, status, result):
+        """
+        Acknowledges the update of action executions with status, result, and end timestamp.
+
+        :param action_execution_ids: A single ID or list of action execution IDs.
+        :param status: The status of the execution (e.g., "succeeded", "failed").
+        :param result: A result object, typically a dict with execution outcome or error.
+        """
+        if not isinstance(action_execution_ids, list):
+            action_execution_ids = [action_execution_ids]
+
+        # StackStorm-style ISO 8601 timestamp with milliseconds and UTC 'Z'
+        end_timestamp = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+        payloads = [
+            {
+                "action_execution_id": action_id,
+                "status": status,
+                "result": result,
+                "end_timestamp": end_timestamp
+            }
+            for action_id in action_execution_ids
+        ]
+
+        return self._send_request(payloads)
\ No newline at end of file
diff --git a/virtana_pack/sensors/lib/auth_helper.py b/virtana_pack/sensors/lib/auth_helper.py
new file mode 100644
index 00000000..18c72ec7
--- /dev/null
+++ b/virtana_pack/sensors/lib/auth_helper.py
@@ -0,0 +1,34 @@
+import requests
+
+
+class AuthHelper:
+    def __init__(self, config):
+
+        self.client_id = config.get("client_id")
+        self.client_secret = config.get("client_secret")
+
+        # Construct API endpoint
+        self.base_url = config.get('base_url')
+        self.auth_url = "/authorization/oauth/token"
+        self.request_url = f"{self.base_url}{self.auth_url}"
+
+    def get_oauth_token(self):
+        """Fetches a new OAuth token for each request"""
+        params = {"override_token": "true"}
+
+        payload = {
+            "grant_type": "client_credentials",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret
+        }
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+        try:
+            response = requests.post(self.request_url, params=params, data=payload, headers=headers, verify=False, timeout=15)
+            response.raise_for_status()
+            data = response.json()
+
+            return data.get("keycloak_access_token")
+
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"OAuth token request failed: {str(e)}")
diff --git a/virtana_pack/sensors/lib/create_action_definitions.py b/virtana_pack/sensors/lib/create_action_definitions.py
new file mode 100644
index 00000000..c92ea68b
--- /dev/null
+++ b/virtana_pack/sensors/lib/create_action_definitions.py
@@ -0,0 +1,91 @@
+import logging
+import requests
+
+from lib.auth_helper import AuthHelper
+from lib.list_actions import list_actions
+
+# Configure Loggingx
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def create_action_definitions(config):
+    """
+    Main function to create action definitions.
+    """
+
+    logger.info("Starting create action definitions execution")
+
+    base_url = config.get("base_url")
+    if not base_url:
+        logger.error("Base URL is missing in configuration.")
+        return False, {"error": "Base URL not found in configuration"}
+
+    request_url = f"{base_url}/api/actions/providers"
+    logger.info(f"Request URL: {request_url}")
+
+    # Fetch action definitions
+    action_definitions = _fetch_action_definitions(config)
+    if action_definitions is None:
+        return False, {"error": "Failed to fetch action definitions"}
+
+    # Retrieve OAuth token
+    token = _get_auth_token(config)
+    if token is None:
+        return False, {"error": "OAuth token retrieval failed"}
+
+    # Send request
+    response = _send_request(request_url, action_definitions, token)
+
+    return True, response if isinstance(response, dict) else {"response": response}
+
+
+def _fetch_action_definitions(config):
+    """
+    Fetch action definitions using the list_actions function.
+    """
+    try:
+        actions_response = list_actions(config)
+        if not actions_response:
+            logger.error("Failed to fetch action definitions.")
+            return None
+        return actions_response
+    except Exception as e:
+        logger.error("Error fetching action definitions.", exc_info=True)
+        return None
+
+
+def _get_auth_token(config):
+    """
+    Retrieve OAuth token using AuthHelper.
+    """
+    try:
+        auth_helper = AuthHelper(config)
+        token = auth_helper.get_oauth_token()
+        if not token:
+            logger.error("OAuth token retrieval failed.")
+            return None
+        logger.debug(f"Retrieved OAuth token: {token[:30]}... (truncated for security)")
+        return token
+    except Exception as e:
+        logger.error("Error retrieving OAuth token.", exc_info=True)
+        return None
+
+
+def _send_request(url, data, token):
+    """
+    Send a PUT request to the API endpoint.
+    """
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+
+    try:
+        response = requests.put(url, json=data, headers=headers, verify=False, timeout=15)
+        response.raise_for_status()
+        logger.info("Request successful.")
+
+        if "application/json" in response.headers.get("Content-Type", ""):
+            return response.json()
+        return response.text
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request failed: {str(e)}", exc_info=True)
+        return {"error": str(e)}
diff --git a/virtana_pack/sensors/lib/disable_sensor.py b/virtana_pack/sensors/lib/disable_sensor.py
new file mode 100644
index 00000000..ca8632f6
--- /dev/null
+++ b/virtana_pack/sensors/lib/disable_sensor.py
@@ -0,0 +1,39 @@
+import logging
+from st2client.client import Client
+
+# Configure Logger
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def disable_sensor(sensor_name, pack_name):
+    """
+    Disables the given sensor inside StackStorm using the Client.
+
+    :param sensor_name: Name of the sensor to disable.
+    :param pack_name: Pack name where the sensor belongs.
+    :return: Tuple (success: bool, message: str)
+    """
+    logger.info(f"Received request to disable sensor '{sensor_name}' in pack '{pack_name}'.")
+
+    try:
+        client = Client()
+        sensors = client.sensors.query(pack=pack_name, name=sensor_name)
+
+        if not sensors:
+            logger.warning(f"Sensor '{sensor_name}' not found in pack '{pack_name}'.")
+            return False, f"Sensor '{sensor_name}' not found."
+
+        sensor = sensors[0]
+        if not sensor.enabled:
+            logger.info(f"Sensor '{sensor_name}' is already disabled.")
+            return True, f"Sensor '{sensor_name}' is already disabled."
+
+        sensor.enabled = False
+        client.sensors.update(sensor)
+        logger.info(f"Sensor '{sensor_name}' disabled successfully.")
+        return True, f"Sensor '{sensor_name}' disabled successfully."
+
+    except Exception as e:
+        logger.error(f"Unexpected error while disabling sensor '{sensor_name}': {str(e)}", exc_info=True)
+        return False, f"Unexpected error: {str(e)}"
diff --git a/virtana_pack/sensors/lib/list_actions.py b/virtana_pack/sensors/lib/list_actions.py
new file mode 100644
index 00000000..12b77122
--- /dev/null
+++ b/virtana_pack/sensors/lib/list_actions.py
@@ -0,0 +1,133 @@
+import json
+import logging
+
+from st2client.client import Client
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def list_actions(config, pack_name=None):
+    """
+    Fetches and filters StackStorm actions based on the given pack name and config filters.
+    """
+    logger.info("Starting list_actions execution.")
+
+    client = Client()
+    provider_id, package_filters, tag_filters = get_provider_details(config)
+
+    packs_to_fetch = [pack_name] if pack_name else package_filters
+
+    logger.info(f"Fetching actions for packs: {packs_to_fetch if packs_to_fetch else 'ALL PACKS'}")
+    logger.info(f"Filtering actions with tags: {tag_filters if tag_filters else 'NO TAG FILTERING'}")
+
+    try:
+        filtered_actions = []
+
+        if packs_to_fetch:
+            for pack in packs_to_fetch:
+                actions = fetch_actions(client, pack)
+                filtered_actions.extend(filter_actions(actions, tag_filters))
+        else:
+            all_actions = fetch_actions(client)
+            filtered_actions = filter_actions(all_actions, tag_filters)
+
+        logger.info(f"Total filtered actions: {len(filtered_actions)}")
+        response = format_action_response(filtered_actions, provider_id)
+
+        result_json = json.dumps(response, indent=2)
+        logger.info(f"Final Response: {result_json}")
+
+        return response
+    except Exception as e:
+        logger.error(f"Unexpected error in list_actions: {str(e)}", exc_info=True)
+        return {"error": "Failed to fetch actions", "details": str(e)}
+
+
+def get_provider_details(config):
+    """
+    Extracts provider ID and filtering criteria from the configuration.
+    """
+    provider_data = config.get("provider_data", {})
+    provider_id = provider_data.get("providerId", "")
+    if not provider_id:
+        logger.warning("Provider ID not found in config, defaulting to empty providerId.")
+
+    filter_criteria = provider_data.get("actionsFilterCriteria", {})
+    package_filters = _parse_csv(filter_criteria.get("packageName", ""))
+    tag_filters = _parse_csv(filter_criteria.get("tagName", ""))
+
+    return provider_id, package_filters, tag_filters
+
+
+def fetch_actions(client, pack_name=None):
+    """
+    Fetches actions from StackStorm based on the provided pack name.
+    """
+    try:
+        return client.actions.query(pack=pack_name) if pack_name else client.actions.query()
+    except Exception as e:
+        logger.error(f"StackStorm API error while fetching actions for pack '{pack_name}': {str(e)}")
+        return []
+
+
+def filter_actions(actions, tag_filters):
+    """
+    Filters actions based on the specified tag filters.
+    """
+    if not tag_filters:
+        return actions  # No filtering needed
+
+    return [
+        action for action in actions
+        if any(tag.get("name") in tag_filters for tag in action.tags)
+    ]
+
+
+def format_action_response(filtered_actions, provider_id):
+    """
+    Formats the filtered actions into a structured response.
+    """
+    action_defs = [
+        {
+            "type": action.name,
+            "name": action.name,
+            "description": action.description,
+            "uid": action.uid,
+            "enabled": action.enabled,
+            "externalRef": action.ref,
+            "parameters": [
+                {
+                    "key": param_key,
+                    "type": param_details.get("type", "string"),
+                    "value": param_details.get("value", ""),
+                    "displayName": param_details.get("display_name", param_key),
+                    "required": param_details.get("required", False),
+                    "defaultValue": param_details.get("default", ""),
+                    "description": param_details.get("description", "")
+                }
+                for param_key, param_details in action.parameters.items()
+            ],
+            "metadata": {
+                "tags": [tag["name"] for tag in action.tags],
+                "pack": action.pack,
+                "runner_type": action.runner_type,
+                "notify": action.notify
+            }
+        }
+        for action in filtered_actions
+    ]
+
+    return {
+        "id": provider_id,
+        "providerName": provider_id,
+        "providerType": "STACKSTORM",
+        "actionDefs": action_defs,
+        "isRemote": "true"
+    }
+
+
+def _parse_csv(value):
+    """Helper function to split comma-separated values into a list."""
+    return [v.strip() for v in value.split(",") if v.strip()]
diff --git a/virtana_pack/sensors/lib/mongo_helper.py b/virtana_pack/sensors/lib/mongo_helper.py
new file mode 100644
index 00000000..670ec6ff
--- /dev/null
+++ b/virtana_pack/sensors/lib/mongo_helper.py
@@ -0,0 +1,111 @@
+from pymongo import MongoClient
+import logging
+from datetime import datetime, timezone
+import configparser
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+class MongoHelper:
+    def __init__(self, config):
+        self.mongo_uri = config.get("mongo_uri")
+        self.database_name = config.get("database_name", "st2")
+        self.collection_name = config.get("collection_name", "action_executions")
+
+        # Fallback to st2.docker.conf if no config present
+        if not self.mongo_uri:
+            fallback_config = self._load_st2_docker_config()
+            self.mongo_uri = self.mongo_uri or fallback_config.get("mongo_uri")
+            self.database_name = self.database_name or fallback_config.get("database_name")
+
+        # Initialize MongoDB client
+        self.client = MongoClient(self.mongo_uri)
+        self.db = self.client[self.database_name]
+        self.collection = self.db[self.collection_name]
+
+    @staticmethod
+    def _load_st2_docker_config(path="/etc/st2/st2.docker.conf"):
+        logger.info("....Reading st2.docker.conf Mongo...")
+        """Reads and parses st2.docker.conf file for MongoDB connection without using os."""
+        fallback = {
+            "mongo_uri": "mongodb://mongo:27017",
+            "database_name": "st2"
+        }
+
+        try:
+            config_parser = configparser.ConfigParser()
+            with open(path, "r") as f:
+                config_parser.read_file(f)
+
+            db_section = config_parser["database"]
+
+            host = db_section.get("host", fallback["mongo_uri"])
+            username = db_section.get("username", "")
+            password = db_section.get("password", "")
+            db_name = db_section.get("db_name", fallback["database_name"])
+
+            if username and password:
+                if "@" not in host and "://" in host:
+                    scheme, rest = host.split("://", 1)
+                    host = f"{scheme}://{username}:{password}@{rest}"
+            else:
+                logger.info("No MongoDB credentials found in st2.docker.conf, proceeding without auth.")
+
+            return {
+                "mongo_uri": host,
+                "database_name": db_name
+            }
+
+        except Exception as e:
+            logger.warning(f"Failed to load or parse {path}: {str(e)}. Using fallback config.")
+            return fallback
+
+    @staticmethod
+    def build_execution_document(action_execution_id, execution_id, status):
+        """Constructs an execution document with default values."""
+        now = datetime.now(timezone.utc)
+        return {
+            "action_execution_id": action_execution_id,
+            "execution_id": execution_id,
+            "status": status,
+            "created_on": now,
+            "updated_on": now,
+            "update_sent": False  # Default Boolean value
+        }
+
+    def save_execution(self, action_execution_id, execution_id, status):
+        """Save execution details to MongoDB."""
+        try:
+            document = self.build_execution_document(action_execution_id,execution_id, status)
+            self.collection.insert_one(document)
+            logger.info(f"Saved execution record to MongoDB: {document}")
+        except Exception as e:
+            logger.error(f"Failed to save execution record to MongoDB: {str(e)}")
+
+    def find_execution_by_id(self, execution_id):
+        """Find an execution by its execution_id."""
+        try:
+            return self.collection.find_one({"execution_id": execution_id})
+        except Exception as e:
+            logger.error(f"Failed to find execution record for execution_id {execution_id}: {str(e)}")
+            return None
+
+    def get_all_executions(self):
+        """Fetch all execution records from MongoDB."""
+        try:
+            return list(self.collection.find({}, {"_id": 0}))  # Exclude MongoDB's internal `_id` field
+        except Exception as e:
+            logger.error(f"Failed to fetch execution records: {str(e)}")
+            return []
+
+    def delete_executions_by_ids(self, execution_ids):
+        """Delete executions from MongoDB based on execution IDs."""
+        try:
+            result = self.collection.delete_many({"execution_id": {"$in": execution_ids}})
+            logger.info(f"Deleted {result.deleted_count} execution(s) from MongoDB.")
+            return result.deleted_count
+        except Exception as e:
+            logger.error(f"Failed to delete execution records: {str(e)}")
+            return 0
\ No newline at end of file
diff --git a/virtana_pack/sensors/lib/update_and_cleanup_executions.py b/virtana_pack/sensors/lib/update_and_cleanup_executions.py
new file mode 100644
index 00000000..53206cfa
--- /dev/null
+++ b/virtana_pack/sensors/lib/update_and_cleanup_executions.py
@@ -0,0 +1,46 @@
+import logging
+from lib.mongo_helper import MongoHelper
+from lib.action_status_notifier import ActionStatusNotifier
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def update_and_cleanup_executions(config):
+    """
+    Fetch execution records, send status updates, and remove completed executions from MongoDB.
+    """
+    mongo_helper = MongoHelper(config)
+    status_notifier = ActionStatusNotifier(config)
+
+    try:
+        execution_records = mongo_helper.get_all_executions()
+        if not execution_records:
+            logger.info("No execution records found.")
+            return True, "No executions to process."  # Changed False to True
+
+        execution_ids = [record["execution_id"] for record in execution_records if "execution_id" in record]
+        if not execution_ids:
+            logger.info("No valid execution IDs found.")
+            return True, "No valid execution IDs."  # Changed False to True
+
+        logger.info(f"Updating statuses for {len(execution_ids)} executions...")
+        success, completed_execution_ids = status_notifier.send_execution_update(execution_ids)
+
+        if not success:
+            logger.error(f"Failed to update execution statuses: {completed_execution_ids}")
+            return False, completed_execution_ids
+
+        if completed_execution_ids:
+            deleted_count = mongo_helper.delete_executions_by_ids(completed_execution_ids)
+            logger.info(f"Deleted {deleted_count} completed executions.")
+        else:
+            logger.info("No completed executions to delete.")
+            return True, "No completed executions to delete."  # Ensure success when nothing to delete
+
+        return True, "Execution processing completed."
+
+    except Exception as e:
+        logger.error(f"Error in execution processing: {str(e)}")
+        return False, str(e)
diff --git a/virtana_pack/sensors/setup_sensor.py b/virtana_pack/sensors/setup_sensor.py
new file mode 100644
index 00000000..2e75eb95
--- /dev/null
+++ b/virtana_pack/sensors/setup_sensor.py
@@ -0,0 +1,56 @@
+import logging
+
+from lib.create_action_definitions import create_action_definitions
+from lib.disable_sensor import disable_sensor
+from st2reactor.sensor.base import PollingSensor
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class SetupSensor(PollingSensor):
+    def __init__(self, sensor_service, config=None, poll_interval=20):
+        super(SetupSensor, self).__init__(sensor_service=sensor_service,
+                                          config=config,
+                                          poll_interval=poll_interval)
+
+        self.pack_name = config.get("pack_name", "virtana_pack")
+        self.sensor_name = self.__class__.__name__
+
+    def setup(self):
+        """Called when the sensor starts."""
+        logger.info(f"Setup sensor '{self.sensor_name}' for '{self.pack_name}' is initialized.")
+
+    def poll(self):
+        """Runs every 20 seconds and calls create_action_definitions()."""
+        success, response = create_action_definitions(self.config)
+
+        if success:
+            logger.info("Action definitions updated successfully.")
+        else:
+            logger.error(f"Failed to update action definitions: {response}")
+
+        # Call disable_sensor using the class name as the sensor name
+        disable_success, disable_message = disable_sensor(self.sensor_name, self.pack_name)
+
+        if disable_success:
+            logger.info(f"Sensor '{self.sensor_name}' disabled successfully.")
+        else:
+            logger.error(f"Failed to disable sensor '{self.sensor_name}': {disable_message}")
+
+    def cleanup(self):
+        """Called when the sensor stops."""
+        logger.info("Cleaning up SetupSensor")
+
+    def add_trigger(self, trigger):
+        """Called when a trigger is added."""
+        logger.info(f"Trigger added: {trigger}")
+
+    def update_trigger(self, trigger):
+        """Called when an existing trigger is updated."""
+        logger.info(f"Trigger updated: {trigger}")
+
+    def remove_trigger(self, trigger):
+        """Called when a trigger is removed."""
+        logger.info(f"Trigger removed: {trigger}")
diff --git a/virtana_pack/sensors/setup_sensor.yaml b/virtana_pack/sensors/setup_sensor.yaml
new file mode 100644
index 00000000..73006113
--- /dev/null
+++ b/virtana_pack/sensors/setup_sensor.yaml
@@ -0,0 +1,5 @@
+class_name: "SetupSensor"
+entry_point: "setup_sensor.py"
+description: "A sensor that performs the post installation setup for the pack and gets disabled immediately after setup. "
+poll_interval: 20
+enabled: true