Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

Major threading and container executor improvements, gateway logic updates (#1432)

Rich Turner1e3890bf7b86
diff --git a/.ci_cd/aws/cloudformation-create-dashboard.yml b/.ci_cd/aws/cloudformation-create-dashboard.yml
new file mode 100644
index 000000000..31bd590b0
--- /dev/null
+++ b/.ci_cd/aws/cloudformation-create-dashboard.yml
@@ -0,0 +1,294 @@
+# ---------------------------------------------------------------------------------------------------------------------
+# Provisions a cloudwatch dashboard with variables to select which instance to show metrics for, should be one per
+# region.
+# ---------------------------------------------------------------------------------------------------------------------
+AWSTemplateFormatVersion: '2010-09-09'
+Description: 'AWS Linux 2, docker compose, nfs support, cron support, cloud watch logging, route53 updating'
+
+Resources:
+
+ CloudWatchDashboard:
+ Type: AWS::CloudWatch::Dashboard
+ Properties:
+ DashboardName: or-default
+ DashboardBody: !Sub |
+ {
+ "variables": [
+ {
+ "type": "property",
+ "property": "InstanceName",
+ "inputType": "select",
+ "id": "InstanceName",
+ "label": "Instance",
+ "visible": true,
+ "search": "CWAgent-Prometheus MetricName=or_attributes_total",
+ "populateFrom": "InstanceName"
+ },
+ {
+ "type": "property",
+ "property": "InstanceId",
+ "inputType": "select",
+ "id": "InstanceId",
+ "label": "EC2 Instance ID",
+ "visible": true,
+ "search": "CWAgent MetricName=disk_used_percent",
+ "populateFrom": "InstanceId"
+ }
+ ],
+ "widgets": [
+ {
+ "height": 6,
+ "width": 8,
+ "y": 0,
+ "x": 0,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ "CWAgent-Prometheus", "or_attributes_total", "InstanceName", "a", "source", "RulesEngine", { "id": "m1", "yAxis": "left", "label": "Rules" } ],
+ [ "...", "AgentService", { "id": "m3", "yAxis": "left", "label": "Agents" } ],
+ [ "...", "DefaultMQTTHandler", { "id": "m2", "yAxis": "left", "label": "MQTT" } ],
+ [ "...", "AssetResource", { "id": "m4", "yAxis": "left", "label": "HTTP API" } ],
+ [ "...", "WebsocketClient", { "id": "m5", "yAxis": "left", "label": "Websocket" } ],
+ [ ".", "artemis_message_count", ".", ".", "queue", "*.*.writeattributevalue.#", { "id": "m6", "yAxis": "left", "label": "MQTT Backlog" } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "stat": "Sum",
+ "period": 300,
+ "title": "Attribute Events",
+ "yAxis": {
+ "left": {
+ "showUnits": false,
+ "label": "Count",
+ "min": 0
+ }
+ }
+ }
+ },
+ {
+ "height": 6,
+ "width": 8,
+ "y": 6,
+ "x": 8,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ { "expression": "IF(m2,(m1/m2)*1000,0)", "label": "Rule Engines", "id": "e1" } ],
+ [ { "expression": "IF(m4,(m3/m4)*1000,0)", "label": "Attr. Processor", "id": "e2", "yAxis": "right" } ],
+ [ "CWAgent-Prometheus", "or_rules_seconds_sum", "InstanceName", "a", { "id": "m1", "visible": false } ],
+ [ ".", "or_rules_seconds_count", ".", ".", { "id": "m2", "visible": false } ],
+ [ ".", "or_attributes_seconds_sum", ".", ".", { "id": "m3", "visible": false } ],
+ [ ".", "or_attributes_seconds_count", ".", ".", { "id": "m4", "visible": false } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "stat": "Sum",
+ "period": 300,
+ "title": "Execution Time",
+ "yAxis": {
+ "left": {
+ "showUnits": false,
+ "label": "ms",
+ "min": 0
+ },
+ "right": {
+ "showUnits": false,
+ "label": "ms",
+ "min": 0
+ }
+ }
+ }
+ },
+ {
+ "height": 6,
+ "width": 8,
+ "y": 12,
+ "x": 8,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ "CWAgent-Prometheus", "haproxy_server_current_sessions", "server", "manager", "proxy", "mqtt", "InstanceName", "a", { "label": "MQTT" } ],
+ [ "...", "manager_backend", ".", ".", { "label": "HTTP/WS" } ],
+ [ "...", "keycloak", ".", "keycloak_backend", ".", ".", { "label": "Keycloak" } ],
+ [ ".", "haproxy_server_http_responses_total", ".", ".", ".", ".", ".", ".", "code", "5xx", { "label": "Keycloak 5xx", "yAxis": "right" } ],
+ [ "...", "manager", ".", "manager_backend", ".", ".", ".", ".", { "label": "Manager 5xx", "yAxis": "right" } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "title": "Proxy Sessions & Errors",
+ "stat": "Maximum",
+ "period": 300,
+ "yAxis": {
+ "left": {
+ "min": 0,
+ "label": "Count",
+ "showUnits": false
+ },
+ "right": {
+ "min": 0,
+ "label": "Count",
+ "showUnits": false
+ }
+ }
+ }
+ },
+ {
+ "height": 6,
+ "width": 8,
+ "y": 12,
+ "x": 0,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ "CWAgent-Prometheus", "haproxy_server_bytes_in_total", "server", "manager", "proxy", "mqtt", "InstanceName", "a", { "label": "MQTT Bytes In" } ],
+ [ ".", "haproxy_server_bytes_out_total", ".", ".", ".", ".", ".", ".", { "label": "MQTT Bytes Out" } ],
+ [ "...", "keycloak", ".", "keycloak_backend", ".", ".", { "label": "Keycloak Bytes Out" } ],
+ [ ".", "haproxy_server_bytes_in_total", ".", ".", ".", ".", ".", ".", { "label": "Keycloak Bytes In" } ],
+ [ "...", "manager", ".", "manager_backend", ".", ".", { "label": "HTTP/WS Bytes In" } ],
+ [ ".", "haproxy_server_bytes_out_total", ".", ".", ".", ".", ".", ".", { "label": "HTTP/WS Bytes Out" } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "title": "Proxy I/O",
+ "stat": "Sum",
+ "period": 300,
+ "yAxis": {
+ "left": {
+ "min": 0
+ }
+ }
+ }
+ },
+ {
+ "height": 6,
+ "width": 8,
+ "y": 0,
+ "x": 8,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ { "expression": "m1-m2", "label": "Dynamic Threads", "id": "e1" } ],
+ [ { "expression": "IF(m4,(m3/m4)*1000,0)", "label": "Execution Time", "id": "e2", "yAxis": "right" } ],
+ [ "CWAgent-Prometheus", "executor_pool_size_threads", "InstanceName", "a", "name", "ContainerExecutor", { "id": "m1", "visible": false, "stat": "Maximum" } ],
+ [ ".", "executor_pool_core_threads", ".", ".", ".", ".", { "id": "m2", "visible": false, "stat": "Maximum" } ],
+ [ ".", "executor_seconds_sum", ".", ".", ".", ".", { "id": "m3", "visible": false } ],
+ [ ".", "executor_seconds_count", ".", ".", ".", ".", { "id": "m4", "visible": false } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "title": "Container Threads",
+ "stat": "Sum",
+ "period": 300,
+ "yAxis": {
+ "left": {
+ "min": 0,
+ "showUnits": false,
+ "label": "Count"
+ },
+ "right": {
+ "min": 0,
+ "showUnits": false,
+ "label": "ms"
+ }
+ }
+ }
+ },
+ {
+ "height": 9,
+ "width": 8,
+ "y": 9,
+ "x": 16,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ "AWS/EC2", "EBSReadOps", "InstanceId", "a", { "label": "Read", "id": "m1", "visible": false, "stat": "Sum" } ],
+ [ ".", "EBSWriteOps", ".", ".", { "label": "Write", "id": "m2", "stat": "Sum", "visible": false } ],
+ [ ".", "CPUCreditBalance", ".", ".", { "yAxis": "left", "label": "CPU Credit Balance", "id": "m3", "stat": "Average", "visible": false } ],
+ [ ".", "CPUUtilization", ".", ".", { "label": "CPU Utilization %", "id": "m4", "yAxis": "right" } ],
+ [ ".", "EBSIOBalance%", ".", ".", { "label": "EBS IO Balance %", "yAxis": "right" } ],
+ [ { "expression": "m1/DIFF_TIME(m1)", "label": "Read IOPS", "id": "e1" } ],
+ [ { "expression": "m2/DIFF_TIME(m2)", "label": "Write IOPS", "id": "e2" } ],
+ [ { "expression": "m3/100", "label": "CPU Credit Balance (x100)", "id": "e3" } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "title": "EC2",
+ "stat": "Maximum",
+ "period": 300,
+ "yAxis": {
+ "left": {
+ "min": 0
+ },
+ "right": {
+ "min": 0,
+ "max": 100
+ }
+ }
+ }
+ },
+ {
+ "height": 9,
+ "width": 8,
+ "y": 0,
+ "x": 16,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ "CWAgent", "mem_used_percent", "InstanceId", "a", { "label": "Memory Usage %" } ],
+ [ "CWAgent", "disk_used_percent", ".", ".", "path", "/", "fstype", "xfs", { "label": "Disk Usage %" } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "stat": "Average",
+ "period": 900,
+ "title": "Disk & Memory",
+ "yAxis": {
+ "left": {
+ "min": 0,
+ "max": 100
+ }
+ }
+ }
+ },
+ {
+ "height": 6,
+ "width": 8,
+ "y": 6,
+ "x": 0,
+ "type": "metric",
+ "properties": {
+ "metrics": [
+ [ { "expression": "IF(m2,(m1/m2)*1000,0)", "label": "Processing Time", "id": "e1", "yAxis": "right" } ],
+ [ "CWAgent-Prometheus", "or_provisioning_seconds_sum", "InstanceName", "a", { "id": "m1", "yAxis": "left", "visible": false } ],
+ [ ".", "or_provisioning_seconds_count", ".", ".", { "id": "m2", "yAxis": "left", "label": "Count" } ],
+ [ ".", "artemis_message_count", ".", ".", "queue", "provisioning.*.request", { "id": "m3", "yAxis": "left", "label": "Backlog" } ]
+ ],
+ "view": "timeSeries",
+ "stacked": false,
+ "region": "${AWS::Region}",
+ "stat": "Sum",
+ "period": 300,
+ "title": "Provisioning Requests",
+ "yAxis": {
+ "left": {
+ "showUnits": false,
+ "label": "Count",
+ "min": 0
+ },
+ "right": {
+ "showUnits": false,
+ "label": "ms",
+ "min": 0
+ }
+ }
+ }
+ }
+ ]
+ }
diff --git a/.ci_cd/aws/cloudformation-create-ec2.yml b/.ci_cd/aws/cloudformation-create-ec2.yml
index b45535973..54387bd7c 100644
--- a/.ci_cd/aws/cloudformation-create-ec2.yml
+++ b/.ci_cd/aws/cloudformation-create-ec2.yml
@@ -21,7 +21,7 @@
#
# - [DAILY] - Cleanup journalctl logs
#
-# ---------------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------------------------------------------------
AWSTemplateFormatVersion: '2010-09-09'
Description: 'AWS Linux 2, docker compose, nfs support, cron support, cloud watch logging, route53 updating'
@@ -43,12 +43,11 @@ Parameters:
EFSDNS:
Description: EFS DNS entry (for maps - IP address of EFS mount target in the same AZ ID)
Type: String
-# Old string based image ID
-# ImageId:
-# Description: AMI ID
-# Type: String
-# Default: "ami-062cd09187a31b743"
ImageId:
+ Description: AMI ID
+ Type: String
+ Default: ""
+ ImageAMI:
Description: AMI ID
Type: 'AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>'
Default: '/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-arm64'
@@ -85,6 +84,13 @@ Parameters:
- true
- false
Default: false
+ Metrics:
+ Description: Enable metrics collection
+ Type: String
+ AllowedValues:
+ - true
+ - false
+ Default: false
DiskSize:
Description: Root EBS volume size GB
Type: Number
@@ -120,7 +126,9 @@ Parameters:
Conditions:
AssignElasticIP: !Equals [!Ref ElasticIP, "true"]
+ MetricsEnabled: !Equals [!Ref Metrics, "true"]
CreateHealthChecks: !Equals [!Ref HealthChecks, "true"]
+ UseAMIID: !Equals [!Ref ImageId, ""]
Resources:
InstanceRoleProfile:
@@ -237,184 +245,205 @@ Resources:
cloudwatch_config:
files:
"/opt/aws/amazon-cloudwatch-agent/var/config.json":
- content: |
- {
- "metrics": {
- "append_dimensions": {
- "AutoScalingGroupName": "${aws:AutoScalingGroupName}",
- "ImageId": "${aws:ImageId}",
- "InstanceId": "${aws:InstanceId}",
- "InstanceType": "${aws:InstanceType}"
+ content: !If
+ - MetricsEnabled
+ - |
+ {
+ "agent":{
+ "metrics_collection_interval": 300
},
- "metrics_collected": {
- "mem": {
- "measurement": [
- "mem_used_percent"
- ],
- "metrics_collection_interval": 600
+ "metrics": {
+ "append_dimensions": {
+ "InstanceId": "${aws:InstanceId}"
},
- "disk": {
- "drop_device": true,
- "measurement": [
- "used_percent"
- ],
- "resources": [
- "/"
- ],
- "metrics_collection_interval": 1800
+ "metrics_collected": {
+ "mem": {
+ "measurement": [
+ "mem_used_percent"
+ ],
+ "metrics_collection_interval": 900
+ },
+ "disk": {
+ "drop_device": true,
+ "measurement": [
+ "used_percent"
+ ],
+ "resources": [
+ "/"
+ ],
+ "metrics_collection_interval": 900
+ }
}
- }
- },
- "logs": {
- "metrics_collected": {
- "prometheus": {
- "log_group_name": "Prometheus",
- "prometheus_config_path": "/opt/aws/amazon-cloudwatch-agent/var/prometheus.yaml",
- "emf_processor": {
- "metric_declaration_dedup": true,
- "metric_namespace": "CWAgent-Prometheus",
- "metric_unit": {
- "or_rules_facts": "Count",
- "or_rules_firing_sum": "Seconds",
- "or_rules_firing_count": "Count",
- "or_camel_route_queue_size": "Count",
- "or_camel_route_failed_total": "Count",
- "or_camel_route_failed_queue_full_total": "Count",
- "or_camel_route_total": "Count",
- "or_camel_route_seconds_sum": "Seconds",
- "or_camel_route_seconds_count": "Count",
- "executor_seconds_count": "Count",
- "executor_seconds_sum": "Seconds",
- "haproxy_server_current_sessions": "Count",
- "haproxy_server_bytes_in_total": "Bytes",
- "haproxy_server_bytes_out_total": "Bytes",
- "haproxy_server_status": "Count",
- "haproxy_server_http_responses_total": "Count",
- "haproxy_server_max_session_rate": "Count/Second",
- "haproxy_server_total_time_average_seconds": "Seconds"
- },
- "metric_declaration": [
- {
- "source_labels": [ "job" ],
- "label_matcher": "^manager$",
- "dimensions": [
- [ "instance_name","id","type" ]
- ],
- "metric_selectors": [
- "^or_rules.*$"
- ]
- },
- {
- "source_labels": [ "job" ],
- "label_matcher": "^manager$",
- "dimensions": [
- [ "instance_name","routeId" ]
- ],
- "metric_selectors": [
- "^or_camel_route.*$"
- ]
- },
- {
- "source_labels": [ "job" ],
- "label_matcher": "^manager$",
- "dimensions": [
- [ "instance_name" ]
- ],
- "metric_selectors": [
- "^or_camel_route_failed_queue_full_total$"
- ]
- },
- {
- "source_labels": [ "job" ],
- "label_matcher": "^manager$",
- "dimensions": [
- [ "instance_name","name" ]
- ],
- "metric_selectors": [
- "^executor_seconds.*$"
- ]
- },
- {
- "source_labels": [ "job" ],
- "label_matcher": "^proxy$",
- "dimensions": [
- [ "instance_name", "proxy", "server" ]
- ],
- "metric_selectors": [
- "^haproxy_server_total_time_average_seconds$",
- "^haproxy_server_max_session_rate$",
- "^haproxy_server_bytes.*$",
- "^haproxy_server_current_sessions$"
- ]
- },
- {
- "source_labels": [ "job" ],
- "label_matcher": "^proxy$",
- "dimensions": [
- [ "instance_name", "proxy", "server", "code" ]
- ],
- "metric_selectors": [
- "^haproxy_server_http_responses_total$"
- ]
+ },
+ "logs": {
+ "metrics_collected": {
+ "prometheus": {
+ "log_group_name": "Prometheus",
+ "prometheus_config_path": "/opt/aws/amazon-cloudwatch-agent/var/prometheus.yaml",
+ "emf_processor": {
+ "metric_declaration_dedup": true,
+ "metric_namespace": "CWAgent-Prometheus",
+ "metric_unit": {
+ "artemis_message_count": "Count",
+ "artemis_messages_added": "Count",
+ "or_rules_seconds_max": "Seconds",
+ "or_rules_seconds_sum": "Seconds",
+ "or_rules_seconds_count": "Count",
+ "or_attributes_seconds_max": "Seconds",
+ "or_attributes_seconds_sum": "Seconds",
+ "or_attributes_seconds_count": "Count",
+ "or_attributes_total": "Count",
+ "or_provisioning_seconds_max": "Seconds",
+ "or_provisioning_seconds_sum": "Seconds",
+ "or_provisioning_seconds_count": "Count",
+ "executor_pool_size_threads": "Count",
+ "executor_pool_core_threads": "Count",
+ "executor_pool_max_threads": "Count",
+ "executor_seconds_count": "Count",
+ "executor_seconds_sum": "Seconds",
+ "haproxy_server_current_sessions": "Count",
+ "haproxy_server_bytes_in_total": "Bytes",
+ "haproxy_server_bytes_out_total": "Bytes",
+ "haproxy_server_status": "Count",
+ "haproxy_server_http_responses_total": "Count",
+ "haproxy_server_max_session_rate": "Count/Second",
+ "haproxy_server_total_time_average_seconds": "Seconds"
},
- {
- "source_labels": [ "job" ],
- "label_matcher": "^proxy$",
- "dimensions": [
- [ "instance_name", "proxy", "server", "state" ]
- ],
- "metric_selectors": [
- "^haproxy_server_status$"
- ]
- }
- ]
+ "metric_declaration": [
+ {
+ "source_labels": [ "job" ],
+ "label_matcher": "^manager$",
+ "dimensions": [
+ [ "InstanceName" ]
+ ],
+ "metric_selectors": [
+ "^or_rules_seconds_count$",
+ "^or_rules_seconds_sum$",
+ "^or_rules_seconds_max$",
+ "^or_attributes_seconds_count$",
+ "^or_attributes_seconds_sum$",
+ "^or_attributes_seconds_max$",
+ "^or_provisioning_seconds_count$",
+ "^or_provisioning_seconds_sum$",
+ "^or_provisioning_seconds_max$"
+ ]
+ },
+ {
+ "source_labels": [ "job", "source" ],
+ "label_matcher": "manager;(RulesEngine|AgentService|DefaultMQTTHandler|AssetResource|WebsocketClient)",
+ "dimensions": [
+ [ "InstanceName", "source" ]
+ ],
+ "metric_selectors": [
+ "^or_attributes_total$"
+ ]
+ },
+ {
+ "source_labels": [ "job", "name" ],
+ "label_matcher": "^manager;ContainerExecutor$",
+ "dimensions": [
+ [ "InstanceName","name" ]
+ ],
+ "metric_selectors": [
+ "^executor_pool_",
+ "^executor_seconds_count$",
+ "^executor_seconds_sum$"
+ ]
+ },
+ {
+ "source_labels": [ "job" ],
+ "label_matcher": "^manager$",
+ "dimensions": [
+ [ "InstanceName","queue" ]
+ ],
+ "metric_selectors": [
+ "^artemis_message_count$",
+ "^artemis_messages_added$"
+ ]
+ },
+ {
+ "source_labels": [ "job" ],
+ "label_matcher": "^proxy$",
+ "dimensions": [
+ [ "InstanceName", "proxy", "server" ]
+ ],
+ "metric_selectors": [
+ "^haproxy_server_total_time_average_seconds$",
+ "^haproxy_server_max_session_rate$",
+ "^haproxy_server_bytes",
+ "^haproxy_server_current_sessions$"
+ ]
+ },
+ {
+ "source_labels": [ "job" ],
+ "label_matcher": "^proxy$",
+ "dimensions": [
+ [ "InstanceName", "proxy", "server", "code" ]
+ ],
+ "metric_selectors": [
+ "^haproxy_server_http_responses_total$"
+ ]
+ },
+ {
+ "source_labels": [ "job" ],
+ "label_matcher": "^proxy$",
+ "dimensions": [
+ [ "InstanceName", "proxy", "server", "state" ]
+ ],
+ "metric_selectors": [
+ "^haproxy_server_status$"
+ ]
+ }
+ ]
+ }
}
}
}
}
- }
-
+ - '{}'
"/opt/aws/amazon-cloudwatch-agent/var/prometheus.yaml":
- content: !Sub |
- # Prometheus scrape config file
- global:
- scrape_interval: 5m
- scrape_timeout: 10s
- scrape_configs:
- - job_name: proxy
- sample_limit: 10000
- static_configs:
- - targets:
- - localhost:8404
- - labels:
- instance_name: '${Host}' # DOESN'T WORK https://github.com/aws/amazon-cloudwatch-agent/issues/751
- metric_relabel_configs:
- - action: keep
- source_labels: [__name__,state,code]
- regex: '(haproxy_server_current_sessions;;|haproxy_server_bytes_in_total;;|haproxy_server_bytes_out_total;;|haproxy_server_status;UP;|haproxy_server_http_responses_total;;5xx|haproxy_server_max_session_rate;;|haproxy_server_total_time_average_seconds;;)'
- - action: replace # THIS IS A WORKAROUND FOR BROKEN LABELS ABOVE
- source_labels: [ instance_name ]
- regex: '(.*)'
- replacement: '${Host}'
- target_label: instance_name
-
- - job_name: manager
- sample_limit: 10000
- static_configs:
- - targets:
- - localhost:8405
- - labels:
- instance_name: '${Host}' # DOESN'T WORK https://github.com/aws/amazon-cloudwatch-agent/issues/751
- metric_relabel_configs:
- - action: keep
- source_labels: [__name__,routeId,name]
- regex: '(or_camel_route_failed_queue_full_total;;|or_camel_route_total;AttributeEvent-Router;|or_camel_route_seconds_count;AttributeEvent-Processor1;|or_camel_route_seconds_sum;AttributeEvent-Processor1;|or_camel_route_total;NotificationQueue;|or_camel_route_failed_handled_total;NotificationQueue;|or_rules_.*|executor_seconds_count;;RulesService|executor_seconds_sum;;RulesService)'
- - action: replace # THIS IS A WORKAROUND FOR BROKEN LABELS ABOVE
- source_labels: [instance_name]
- regex: '(.*)'
- replacement: '${Host}'
- target_label: instance_name
-
+ content: !If
+ - MetricsEnabled
+ - !Sub |
+ # Prometheus scrape config file
+ global:
+ scrape_interval: 100s
+ scrape_timeout: 10s
+ scrape_configs:
+ - job_name: proxy
+ sample_limit: 10000
+ static_configs:
+ - targets:
+ - localhost:8404
+ - labels:
+ InstanceName: '${Host}' # DOESN'T WORK https://github.com/aws/amazon-cloudwatch-agent/issues/751
+ metric_relabel_configs:
+ - action: keep
+ source_labels: [__name__,state,code]
+ regex: '(haproxy_server_current_sessions;;|haproxy_server_bytes_in_total;;|haproxy_server_bytes_out_total;;|haproxy_server_status;UP;|haproxy_server_http_responses_total;;5xx|haproxy_server_max_session_rate;;|haproxy_server_total_time_average_seconds;;)'
+ - action: replace # THIS IS A WORKAROUND FOR BROKEN LABELS ABOVE
+ source_labels: [ InstanceName ]
+ regex: '(.*)'
+ replacement: '${Host}'
+ target_label: InstanceName
+
+ - job_name: manager
+ sample_limit: 10000
+ static_configs:
+ - targets:
+ - localhost:8405
+ - labels:
+ InstanceName: '${Host}' # DOESN'T WORK https://github.com/aws/amazon-cloudwatch-agent/issues/751
+ metric_relabel_configs:
+ - action: keep
+ source_labels: [__name__,name]
+ regex: '(or_rules_.*|or_attributes.*|or.provisioning.*|executor_pool_(core|size).*;ContainerExecutor|executor_seconds_count;ContainerExecutor|executor_seconds_sum;ContainerExecutor|artemis_message_count.*|artemis_messages_added.*)'
+ - action: replace # THIS IS A WORKAROUND FOR BROKEN LABELS ABOVE
+ source_labels: [ InstanceName ]
+ regex: '(.*)'
+ replacement: '${Host}'
+ target_label: InstanceName
+ - "# Prometheus scrape config file"
daily_cleanup:
files:
"/usr/local/bin/daily-cleanup":
@@ -715,6 +744,12 @@ Resources:
if [ -n "${DNSHostedZoneRoleArn}" ]; then
echo "AWS_ROUTE53_ROLE=${DNSHostedZoneRoleArn}" >> /etc/environment
fi
+ 04_metrics:
+ command: !Sub |
+ # Output OR_METRICS_ENABLED to /etc/environment for use by manager container
+ if [ -n "${Metrics}" ]; then
+ echo "OR_METRICS_ENABLED=${Metrics}" >> /etc/environment
+ fi
docker_setup:
packages:
@@ -785,7 +820,7 @@ Resources:
Properties:
InstanceType: !Ref InstanceType
KeyName: "developers"
- ImageId: !Ref ImageId
+ ImageId: !If [UseAMIID, !Ref ImageAMI, !Ref ImageId]
SubnetId: !Ref SubnetId
SecurityGroupIds:
- Ref: SSHSecurityGroupId
@@ -834,6 +869,7 @@ Resources:
# Telemetry and Alarms
EmailSubscription:
+ Condition: CreateHealthChecks
Type: AWS::SNS::Subscription
Properties:
@@ -841,6 +877,7 @@ Resources:
TopicArn: !Ref SnsTopic
SnsTopic:
+ Condition: CreateHealthChecks
Type: AWS::SNS::Topic
Properties:
DisplayName: !Sub ${Host}.${EC2Instance}
@@ -887,6 +924,7 @@ Resources:
CPUUtilizationAlarm:
Type: AWS::CloudWatch::Alarm
+ Condition: MetricsEnabled
Properties:
Namespace: AWS/EC2
MetricName: CPUUtilization
@@ -905,6 +943,7 @@ Resources:
DiskUtilizationAlarm:
Type: AWS::CloudWatch::Alarm
+ Condition: MetricsEnabled
Properties:
Namespace: CWAgent
MetricName: disk_used_percent
@@ -920,10 +959,6 @@ Resources:
Dimensions:
- Name: InstanceId
Value: !Ref EC2Instance
- - Name: ImageId
- Value: !Ref ImageId
- - Name: InstanceType
- Value: !Ref InstanceType
- Name: path
Value: /
- Name: fstype
@@ -931,6 +966,7 @@ Resources:
MemoryUtilizationAlarm:
Type: AWS::CloudWatch::Alarm
+ Condition: MetricsEnabled
Properties:
Namespace: CWAgent
MetricName: mem_used_percent
@@ -946,260 +982,45 @@ Resources:
Dimensions:
- Name: InstanceId
Value: !Ref EC2Instance
- - Name: ImageId
- Value: !Ref ImageId
- - Name: InstanceType
- Value: !Ref InstanceType
- CloudWatchDashboard:
- Type: AWS::CloudWatch::Dashboard
+ ThreadPoolAlarm:
+ Type: AWS::CloudWatch::Alarm
+ Condition: MetricsEnabled
Properties:
- DashboardName: !Join ["-", !Split [ '.', !Ref Host] ]
- DashboardBody: !Sub |
- {
- "widgets": [
- {
- "height": 6,
- "width": 6,
- "y": 0,
- "x": 6,
- "type": "metric",
- "properties": {
- "metrics": [
- [ { "expression": "m11 / m12", "label": "Avg Processor 1 (s)", "id": "e1" } ],
- [ "CWAgent-Prometheus", "or_camel_route_seconds_sum", "routeId", "AttributeEvent-Processor1", "instance_name", "${Host}", { "id": "m11", "visible": false } ],
- [ ".", "or_camel_route_seconds_count", ".", ".", ".", ".", { "id": "m12", "visible": false, "stat": "Maximum" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "stat": "Average",
- "period": 300,
- "title": "Attr Event Processing Time",
- "yAxis": {
- "left": {
- "showUnits": false
- }
- }
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 0,
- "x": 0,
- "type": "metric",
- "properties": {
- "metrics": [
- [ { "expression": "m1/PERIOD(m1)", "label": "Success [/s]", "id": "e1", "region": "eu-west-1" } ],
- [ { "expression": "m2/PERIOD(m2)", "label": "Fail (Queue Full) [/s]", "id": "e2", "region": "eu-west-1" } ],
- [ "CWAgent-Prometheus", "or_camel_route_total", "routeId", "AttributeEvent-Router", "instance_name", "${Host}", { "id": "m1", "label": "Success", "visible": false } ],
- [ ".", "or_camel_route_failed_queue_full_total", "instance_name", "${Host}", { "id": "m2", "label": "Fail (Queue Full)", "visible": false } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "title": "Attr Events Processed",
- "stat": "Sum",
- "period": 300,
- "yAxis": {
- "left": {
- "showUnits": false
- }
- }
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 6,
- "x": 0,
- "type": "metric",
- "properties": {
- "metrics": [
- [ { "expression": "m1 / m2", "label": "Max (s)", "id": "e1" } ],
- [ "CWAgent-Prometheus", "executor_seconds_sum", "instance_name", "${Host}", "name", "RulesService", { "id": "m1", "visible": false } ],
- [ ".", "executor_seconds_count", ".", ".", ".", ".", { "id": "m2", "visible": false } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "stat": "Maximum",
- "period": 300,
- "title": "Rule Engine Execution Time",
- "yAxis": {
- "left": {
- "showUnits": false
- }
- }
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 6,
- "x": 12,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "CWAgent-Prometheus", "haproxy_server_current_sessions", "server", "manager", "proxy", "mqtt", "instance_name", "${Host}", { "label": "MQTT" } ],
- [ "...", "manager_backend", ".", ".", { "label": "HTTP/WS" } ],
- [ "...", "keycloak", ".", "keycloak_backend", ".", ".", { "label": "Keycloak" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "title": "Proxy Active Sessions",
- "stat": "Sum",
- "period": 300
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 0,
- "x": 12,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "CWAgent-Prometheus", "haproxy_server_max_session_rate", "server", "manager", "proxy", "mqtt", "instance_name", "${Host}", { "label": "MQTT" } ],
- [ "...", "manager_backend", ".", ".", { "label": "HTTP/WS" } ],
- [ "...", "keycloak", ".", "keycloak_backend", ".", ".", { "label": "Keycloak" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "title": "Proxy Session Rate",
- "stat": "Average",
- "period": 300
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 12,
- "x": 12,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "CWAgent-Prometheus", "haproxy_server_bytes_in_total", "server", "manager", "proxy", "mqtt", "instance_name", "${Host}", { "label": "MQTT Bytes In" } ],
- [ ".", "haproxy_server_bytes_out_total", ".", ".", ".", ".", ".", ".", { "label": "MQTT Bytes Out" } ],
- [ "...", "keycloak", ".", "keycloak_backend", ".", ".", { "label": "Keycloak Bytes Out" } ],
- [ ".", "haproxy_server_bytes_in_total", ".", ".", ".", ".", ".", ".", { "label": "Keycloak Bytes In" } ],
- [ "...", "manager", ".", "manager_backend", ".", ".", { "label": "HTTP/WS Bytes In" } ],
- [ ".", "haproxy_server_bytes_out_total", ".", ".", ".", ".", ".", ".", { "label": "HTTP/WS Bytes Out" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "title": "Proxy I/O",
- "stat": "Sum",
- "period": 300
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 12,
- "x": 6,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "CWAgent-Prometheus", "haproxy_server_http_responses_total", "server", "keycloak", "proxy", "keycloak_backend", "instance_name", "${Host}", "code", "5xx", { "label": "Keycloak 5xx" } ],
- [ "...", "manager", ".", "manager_backend", ".", ".", ".", ".", { "label": "Manager 5xx" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "title": "HTTP Error Responses",
- "stat": "Sum",
- "period": 300
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 6,
- "x": 18,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "AWS/EBS", "VolumeReadOps", "VolumeId", "vol-08af38ccf9207da16", { "label": "Reads" } ],
- [ ".", "VolumeWriteOps", ".", ".", { "label": "Writes" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "title": "EBS Operations",
- "stat": "Sum",
- "period": 300
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 12,
- "x": 18,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "AWS/EBS", "VolumeReadBytes", "VolumeId", "vol-08af38ccf9207da16", { "label": "Read" } ],
- [ ".", "VolumeWriteBytes", ".", ".", { "label": "Write" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "title": "EBS Bytes",
- "stat": "Sum",
- "period": 300
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 0,
- "x": 18,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "AWS/EC2", "EBSIOBalance%", "InstanceId", "i-0c9e821c9865e70ea", { "label": "EBS IO Balance %" } ],
- [ ".", "EBSByteBalance%", ".", ".", { "label": "EBS Byte Balance %" } ],
- [ ".", "CPUCreditBalance", ".", ".", { "yAxis": "right", "label": "CPU Credit Balance" } ],
- [ ".", "CPUUtilization", ".", ".", { "label": "CPU Utilization %", "stat": "Maximum" } ],
- [ "CWAgent", "mem_used_percent", ".", ".", "ImageId", "ami-062cd09187a31b743", "InstanceType", "t4g.small", { "label": "Memory Usage %", "period": 900 } ],
- [ ".", "disk_used_percent", "path", "/", "InstanceId", "i-0c9e821c9865e70ea", "ImageId", "ami-062cd09187a31b743", "InstanceType", "t4g.small", "fstype", "xfs", { "label": "Disk Usage %", "period": 1800 } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "region": "${AWS::Region}",
- "stat": "Average",
- "period": 300,
- "title": "EC2 Stats"
- }
- },
- {
- "height": 6,
- "width": 6,
- "y": 6,
- "x": 6,
- "type": "metric",
- "properties": {
- "metrics": [
- [ "CWAgent-Prometheus", "or_camel_route_total", "instance_name", "${Host}", "routeId", "NotificationQueue", { "label": "Success" } ],
- [ ".", "or_camel_route_failed_total", ".", ".", ".", ".", { "label": "Fail" } ]
- ],
- "view": "timeSeries",
- "stacked": false,
- "title": "Notifications",
- "region": "${AWS::Region}",
- "stat": "Sum",
- "period": 300,
- "yAxis": {
- "left": {
- "showUnits": false
- }
- }
- }
- }
- ]
- }
+ Metrics:
+ - Expression: m1-m2
+ Id: e1
+ ReturnData: true
+ - Id: m1
+ MetricStat:
+ Metric:
+ MetricName: executor_pool_size_threads
+ Namespace: CWAgent-Prometheus
+ Dimensions:
+ - Name: InstanceName
+ Value: !Ref Host
+ - Name: name
+ Value: ContainerExecutor
+ Period: 300
+ Stat: Average
+ ReturnData: false
+ - Id: m2
+ MetricStat:
+ Metric:
+ MetricName: executor_pool_core_threads
+ Namespace: CWAgent-Prometheus
+ Dimensions:
+ - Name: InstanceName
+ Value: !Ref Host
+ - Name: name
+ Value: ContainerExecutor
+ Period: 300
+ Stat: Average
+ ReturnData: false
+ EvaluationPeriods: 3
+ ComparisonOperator: GreaterThanThreshold
+ Threshold: 0
+ AlarmActions:
+ - !Ref SnsTopic
+ OKActions:
+ - !Ref SnsTopic
diff --git a/.ci_cd/aws/provision_account.sh b/.ci_cd/aws/provision_account.sh
index df7bfcfbe..a7d8519e2 100644
--- a/.ci_cd/aws/provision_account.sh
+++ b/.ci_cd/aws/provision_account.sh
@@ -11,6 +11,7 @@
# * Create Hosted domain zone (if requested) and will create the NS record in the PARENT_DNS_ZONE to delegate to the
# new hosted zone; the zone will use the account name.
# * Adds SSH whitelist to the ssh-access security group in the new account (see refresh_ssh_whitelist.sh)
+# * Adds default OR cloudwatch dashboard that can be used to check any instances configured for metrics collection
#
# Arguments:
# 1 - OU - Name of organizational unit where account should be provisioned (defaults to account root if not set)
@@ -276,6 +277,40 @@ else
echo "PARENT_DNS_ZONE not set so no DNS configuration will be attempted"
fi
+# Provision default dashboard
+if [ -f "${awsDir}cloudformation-create-dashboard.yml" ]; then
+ TEMPLATE_PATH="${awsDir}cloudformation-create-dashboard.yml"
+elif [ -f ".ci_cd/aws/cloudformation-create-dashboard.yml" ]; then
+ TEMPLATE_PATH=".ci_cd/aws/cloudformation-create-dashboard.yml"
+elif [ -f "openremote/.ci_cd/aws/cloudformation-create-dashboard.yml" ]; then
+ TEMPLATE_PATH="openremote/.ci_cd/aws/cloudformation-create-dashboard.yml"
+else
+ echo "Cannot determine location of cloudformation-create-dashboard.yml"
+ exit 1
+fi
+
+STACK_NAME=or-dashboard-default
+
+# Create dashboard in specified account
+STACK_ID=$(aws cloudformation create-stack --capabilities CAPABILITY_NAMED_IAM --stack-name $STACK_NAME --template-body file://$TEMPLATE_PATH --output text $ACCOUNT_PROFILE)
+
+# Wait for cloud formation stack status to be CREATE_*
+echo "Waiting for stack to be created"
+STATUS=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --query "Stacks[?StackId=='$STACK_ID'].StackStatus" --output text $ACCOUNT_PROFILE 2>/dev/null)
+
+while [[ "$STATUS" == 'CREATE_IN_PROGRESS' ]]; do
+ echo "Stack creation is still in progress .. Sleeping 30 seconds"
+ sleep 30
+ STATUS=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --query "Stacks[?StackId=='$STACK_ID'].StackStatus" --output text $ACCOUNT_PROFILE 2>/dev/null)
+done
+
+if [ "$STATUS" != 'CREATE_COMPLETE' ] && [ "$STATUS" != 'UPDATE_COMPLETE' ]; then
+ echo "Stack creation has failed status is '$STATUS'" >&2
+ exit 1
+else
+ echo "Stack creation is complete"
+fi
+
# Update SSH Whitelist for this account
if [ -n "$SGID" ]; then
"${awsDir}refresh_ssh_whitelist.sh" "" "" $AWS_ACCOUNT_ID
diff --git a/.ci_cd/aws/provision_host.sh b/.ci_cd/aws/provision_host.sh
index bcc46743c..e07f1cf13 100644
--- a/.ci_cd/aws/provision_host.sh
+++ b/.ci_cd/aws/provision_host.sh
@@ -21,7 +21,8 @@
# 4 - DISK_SIZE to use for created EBS root volume (GB)
# 5 - ELASTIC_IP if 'true' then create an elastic public IP for this host
# 6 - PROVISION_S3_BUCKET set to 'false' to not provision an S3 bucket for this host
-# 7 - WAIT_FOR_STACK if 'false' script will not wait until the cloud formation stack is running
+# 7 - ENABLE_METRICS set to 'false' to not enable cloudwatch metrics for this instance
+# 8 - WAIT_FOR_STACK if 'false' script will not wait until the cloud formation stack is running
if [[ $BASH_SOURCE = */* ]]; then
awsDir=${BASH_SOURCE%/*}/
@@ -35,7 +36,8 @@ INSTANCE_TYPE=${3,,}
DISK_SIZE=${4,,}
ELASTIC_IP=${5,,}
PROVISION_S3_BUCKET=${6,,}
-WAIT_FOR_STACK=${7,,}
+ENABLE_METRICS=${7,,}
+WAIT_FOR_STACK=${8,,}
if [ -z "$HOST" ]; then
echo "Host must be set"
@@ -140,6 +142,10 @@ else
PARAMS="$PARAMS ParameterKey=ElasticIP,ParameterValue=$ELASTIC_IP"
fi
+ if [ -n "$ENABLE_METRICS" ]; then
+ PARAMS="$PARAMS ParameterKey=Metrics,ParameterValue=$ENABLE_METRICS"
+ fi
+
# Get SMTP credentials
SMTP_HOST="email-smtp.$AWS_REGION.amazonaws.com"
SMTP_USER=$(aws cloudformation describe-stacks --stack-name $SMTP_STACK_NAME --query "Stacks[0].Outputs[?OutputKey=='SMTPUserKey'].OutputValue" --output text 2>/dev/null)
diff --git a/.github/workflows/provision-host.yml b/.github/workflows/provision-host.yml
index 2900832fc..8c2300924 100644
--- a/.github/workflows/provision-host.yml
+++ b/.github/workflows/provision-host.yml
@@ -28,10 +28,15 @@ on:
- m6g.xlarge
required: true
DISK_SIZE:
- description: 'Override EC2 root EBS volume size to provision (GB)'
+ description: 'Override EC2 root EBS volume size (GB)'
type: string
default: '16'
required: false
+ ENABLE_METRICS:
+ description: 'Enable metrics'
+ type: boolean
+ default: true
+ required: false
ELASTIC_IP:
description: 'Create elastic public IP'
type: boolean
@@ -67,7 +72,7 @@ jobs:
if: ${{ steps.checkUserMember.outputs.isTeamMember == 'true' }}
run: |
chmod +x .ci_cd/aws/*
- .ci_cd/aws/provision_host.sh "$ACCOUNT_NAME" "$HOST" "$INSTANCE_TYPE" "$DISK_SIZE" "$ELASTIC_IP" "$PROVISION_S3_BUCKET"
+ .ci_cd/aws/provision_host.sh "$ACCOUNT_NAME" "$HOST" "$INSTANCE_TYPE" "$DISK_SIZE" "$ELASTIC_IP" "$PROVISION_S3_BUCKET" "$ENABLE_METRICS"
env:
ACCOUNT_NAME: ${{ github.event.inputs.ACCOUNT_NAME }}
HOST: ${{ github.event.inputs.HOST }}
@@ -78,3 +83,4 @@ jobs:
AWS_ACCESS_KEY_ID: ${{ secrets._TEMP_AWS_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY: ${{ secrets._TEMP_AWS_SECRET_ACCESS_KEY }}
AWS_ROLE_NAME: ${{ secrets._TEMP_AWS_ROLE_NAME }}
+ ENABLE_METRICS: ${{ github.event.inputs.ENABLE_METRICS }}
diff --git a/agent/src/main/java/org/openremote/agent/protocol/AbstractProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/AbstractProtocol.java
index 25360a891..e349e8b95 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/AbstractProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/AbstractProtocol.java
@@ -38,6 +38,7 @@ import org.openremote.model.util.Pair;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@@ -46,13 +47,14 @@ import static org.openremote.model.syslog.SyslogCategory.PROTOCOL;
public abstract class AbstractProtocol<T extends Agent<T, ?, U>, U extends AgentLink<?>> implements Protocol<T> {
- private static final System.Logger LOG = System.getLogger(AbstractProtocol.class.getSimpleName() + "." + PROTOCOL.name());
+ private static final System.Logger LOG = System.getLogger(AbstractProtocol.class.getName() + "." + PROTOCOL.name());
protected final Map<AttributeRef, Attribute<?>> linkedAttributes = new ConcurrentHashMap<>();
protected final Set<AttributeRef> dynamicAttributes = Collections.synchronizedSet(new HashSet<>());
protected DefaultCamelContext messageBrokerContext;
protected ProducerTemplate producerTemplate;
protected TimerService timerService;
- protected ScheduledExecutorService executorService;
+ protected ExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected ProtocolAssetService assetService;
protected ProtocolPredictedDatapointService predictedDatapointService;
protected ProtocolDatapointService datapointService;
@@ -71,7 +73,8 @@ public abstract class AbstractProtocol<T extends Agent<T, ?, U>, U extends Agent
@Override
public void start(Container container) throws Exception {
timerService = container.getService(TimerService.class);
- executorService = container.getExecutorService();
+ executorService = container.getExecutor();
+ scheduledExecutorService = container.getScheduledExecutor();
predictedDatapointService = container.getService(ProtocolPredictedDatapointService.class);
datapointService = container.getService(ProtocolDatapointService.class);
messageBrokerContext = container.getService(MessageBrokerService.class).getContext();
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshNetwork.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshNetwork.java
index 4664dfc23..a81dcb164 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshNetwork.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshNetwork.java
@@ -19,19 +19,11 @@
*/
package org.openremote.agent.protocol.bluetooth.mesh;
-import com.welie.blessed.BluetoothCentralManager;
-import com.welie.blessed.BluetoothCentralManagerCallback;
-import com.welie.blessed.BluetoothCommandStatus;
-import com.welie.blessed.BluetoothPeripheral;
-import com.welie.blessed.ScanResult;
+import com.welie.blessed.*;
import org.openremote.agent.protocol.bluetooth.mesh.models.SigModel;
import org.openremote.agent.protocol.bluetooth.mesh.models.SigModelParser;
import org.openremote.agent.protocol.bluetooth.mesh.provisionerstates.UnprovisionedMeshNode;
-import org.openremote.agent.protocol.bluetooth.mesh.transport.ControlMessage;
-import org.openremote.agent.protocol.bluetooth.mesh.transport.Element;
-import org.openremote.agent.protocol.bluetooth.mesh.transport.MeshMessage;
-import org.openremote.agent.protocol.bluetooth.mesh.transport.MeshModel;
-import org.openremote.agent.protocol.bluetooth.mesh.transport.ProvisionedMeshNode;
+import org.openremote.agent.protocol.bluetooth.mesh.transport.*;
import org.openremote.model.asset.agent.ConnectionStatus;
import org.openremote.model.syslog.SyslogCategory;
@@ -39,6 +31,7 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Consumer;
import java.util.logging.Logger;
@@ -62,7 +55,8 @@ public class BluetoothMeshNetwork extends BluetoothCentralManagerCallback implem
private volatile MeshManagerApi meshManagerApi;
private volatile boolean isStarted = false;
- private final ScheduledExecutorService executorService;
+ private final ExecutorService executorService;
+ private final ScheduledExecutorService scheduledExecutorService;
private final BluetoothCentralManager bluetoothCentral;
private final SequenceNumberPersistencyManager sequenceNumberManager;
private final MainThreadManager mainThreadManager;
@@ -79,7 +73,7 @@ public class BluetoothMeshNetwork extends BluetoothCentralManagerCallback implem
public BluetoothMeshNetwork(BluetoothCentralManager bluetoothCentral, SequenceNumberPersistencyManager sequenceNumberManager, MainThreadManager mainThread,
String proxyAddress, int unicastAddress, NetworkKey networkKey, Map<Integer, ApplicationKey> applicationKeyMap,
- int mtu, int sequenceNumber, ScheduledExecutorService executorService, Consumer<ConnectionStatus> statusConsumer) {
+ int mtu, int sequenceNumber, ExecutorService executorService, ScheduledExecutorService scheduledExecutorService, Consumer<ConnectionStatus> statusConsumer) {
this.bluetoothCentral = bluetoothCentral;
this.sequenceNumberManager = sequenceNumberManager;
this.mainThreadManager = mainThread;
@@ -89,9 +83,10 @@ public class BluetoothMeshNetwork extends BluetoothCentralManagerCallback implem
this.applicationKeyMap = applicationKeyMap;
this.mtu = mtu;
this.executorService = executorService;
+ this.scheduledExecutorService = scheduledExecutorService;
this.statusConsumer = statusConsumer;
- this.meshManagerApi = new MeshManagerApi(executorService);
+ this.meshManagerApi = new MeshManagerApi(scheduledExecutorService);
this.meshManagerApi.setMeshManagerCallbacks(this);
this.meshManagerApi.setMeshStatusCallbacks(this);
@@ -457,7 +452,7 @@ public class BluetoothMeshNetwork extends BluetoothCentralManagerCallback implem
proxyScanner.stop();
}
executorService.execute(() -> statusConsumer.accept(ConnectionStatus.CONNECTING));
- proxyScanner = new BluetoothMeshProxyScanner(mainThreadManager, bluetoothCentral, executorService);
+ proxyScanner = new BluetoothMeshProxyScanner(mainThreadManager, bluetoothCentral, executorService, scheduledExecutorService);
proxyScanner.start(networkKey, proxyAddress, SCAN_DURATION, new BluetoothMeshProxyScannerCallback() {
@Override
public void onMeshProxiesScanned(List<BluetoothMeshProxy> meshProxies, Integer errorCode) {
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProtocol.java
index c9575532a..500e528d1 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProtocol.java
@@ -124,9 +124,9 @@ public class BluetoothMeshProtocol extends AbstractProtocol<BluetoothMeshAgent,
// Not ideal this but will do for now
private static SequenceNumberPersistencyManager sequenceNumberManager;
- public synchronized static void initMainThread(ScheduledExecutorService executorService) {
+ public synchronized static void initMainThread(ScheduledExecutorService scheduledExecutorService) {
if (mainThreadFuture == null) {
- mainThreadFuture = executorService.schedule(mainThread, 0, TimeUnit.MILLISECONDS);
+ mainThreadFuture = scheduledExecutorService.schedule(mainThread, 0, TimeUnit.MILLISECONDS);
}
}
@@ -229,14 +229,10 @@ public class BluetoothMeshProtocol extends AbstractProtocol<BluetoothMeshAgent,
Map<Integer, ApplicationKey> applicationKeyMap = new HashMap<>();
applicationKeyMap.put(appKeyIndex, applicationKey);
- final ScheduledExecutorService finalExecutorService = executorService;
- Consumer<ConnectionStatus> statusConsumer = new Consumer<ConnectionStatus>() {
- @Override
- public void accept(ConnectionStatus connectionStatus) {
- setConnectionStatus(connectionStatus);
- if (connectionStatus == ConnectionStatus.CONNECTED) {
- finalExecutorService.execute(() -> updateAllAttributes());
- }
+ Consumer<ConnectionStatus> statusConsumer = connectionStatus -> {
+ setConnectionStatus(connectionStatus);
+ if (connectionStatus == ConnectionStatus.CONNECTED) {
+ executorService.execute(this::updateAllAttributes);
}
};
@@ -245,10 +241,10 @@ public class BluetoothMeshProtocol extends AbstractProtocol<BluetoothMeshAgent,
oldSequenceNumber = sequenceNumberParam;
BluetoothMeshProtocol.sequenceNumberManager.save(networkKey, sourceAddress, oldSequenceNumber);
}
- BluetoothMeshProtocol.initMainThread(executorService);
+ BluetoothMeshProtocol.initMainThread(scheduledExecutorService);
meshNetwork = new BluetoothMeshNetwork(
BluetoothMeshProtocol.bluetoothCentral, BluetoothMeshProtocol.sequenceNumberManager, BluetoothMeshProtocol.mainThread,
- proxyAddress, sourceAddress, networkKey, applicationKeyMap, mtuParam, oldSequenceNumber, executorService, statusConsumer
+ proxyAddress, sourceAddress, networkKey, applicationKeyMap, mtuParam, oldSequenceNumber, executorService, scheduledExecutorService, statusConsumer
);
BluetoothMeshProtocol.addNetwork(meshNetwork);
BluetoothMeshProtocol.mainThread.enqueue(() -> meshNetwork.start());
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxy.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxy.java
index fe56aa5a2..bd6c1b952 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxy.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxy.java
@@ -33,6 +33,7 @@ import org.openremote.model.syslog.SyslogCategory;
import java.util.List;
import java.util.UUID;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Consumer;
import java.util.logging.Logger;
@@ -67,11 +68,11 @@ public class BluetoothMeshProxy extends BluetoothCentralManagerCallback {
// Constructors -------------------------------------------------------------------------------
- public BluetoothMeshProxy(MainThreadManager bluetoothCommandSerializer, ScheduledExecutorService executorService, BluetoothCentralManager central, BluetoothPeripheral peripheral, ScanResult scanResult) {
+ public BluetoothMeshProxy(MainThreadManager bluetoothCommandSerializer, ExecutorService executorService, ScheduledExecutorService scheduledExecutorService, BluetoothCentralManager central, BluetoothPeripheral peripheral, ScanResult scanResult) {
this.scanResult = scanResult;
this.rssi = scanResult.getRssi();
this.peripheralCallback = new BluetoothPeripheralCallbackImpl();
- this.stateMachine = new BluetoothMeshProxyStateMachine(this, central, executorService, bluetoothCommandSerializer, peripheral, peripheralCallback);
+ this.stateMachine = new BluetoothMeshProxyStateMachine(this, central, executorService, scheduledExecutorService, bluetoothCommandSerializer, peripheral, peripheralCallback);
}
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyScanner.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyScanner.java
index 3043e368a..b86f5708c 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyScanner.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyScanner.java
@@ -35,6 +35,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
@@ -59,7 +60,8 @@ public class BluetoothMeshProxyScanner extends BluetoothCentralManagerCallback {
private final MainThreadManager bluetoothCommandSerializer;
private final BluetoothCentralManager bluetoothCentral;
- private final ScheduledExecutorService executorService;
+ private final ExecutorService executorService;
+ private final ScheduledExecutorService scheduledExecutorService;
private volatile BluetoothMeshProxyScannerCallback callback;
private volatile NetworkKey networkKey;
private volatile String address;
@@ -72,10 +74,11 @@ public class BluetoothMeshProxyScanner extends BluetoothCentralManagerCallback {
// Constructors -------------------------------------------------------------------------------
- public BluetoothMeshProxyScanner(MainThreadManager bluetoothCommandSerializer, BluetoothCentralManager central, ScheduledExecutorService executorService) {
+ public BluetoothMeshProxyScanner(MainThreadManager bluetoothCommandSerializer, BluetoothCentralManager central, ExecutorService executorService, ScheduledExecutorService scheduledExecutorService) {
this.bluetoothCommandSerializer = bluetoothCommandSerializer;
this.bluetoothCentral = central;
this.executorService = executorService;
+ this.scheduledExecutorService = scheduledExecutorService;
}
public synchronized void start(final NetworkKey networkKey, String address, int duration, final BluetoothMeshProxyScannerCallback callback) {
@@ -93,7 +96,7 @@ public class BluetoothMeshProxyScanner extends BluetoothCentralManagerCallback {
bluetoothCentral.scanForPeripheralsWithServices(new UUID[] {MESH_PROXY_UUID});
};
bluetoothCommandSerializer.enqueue(runnable);
- timeoutFuture = executorService.schedule(() -> {
+ timeoutFuture = scheduledExecutorService.schedule(() -> {
synchronized (BluetoothMeshProxyScanner.this) {
timeoutFuture = null;
executeCallbackAndStopScanner();
@@ -192,7 +195,7 @@ public class BluetoothMeshProxyScanner extends BluetoothCentralManagerCallback {
if (address == null || (address != null && address.equalsIgnoreCase(peripheral.getAddress()))) {
meshProxyMap.put(
peripheral.getAddress(),
- new BluetoothMeshProxy(bluetoothCommandSerializer, executorService, bluetoothCentral, peripheral, scanResult)
+ new BluetoothMeshProxy(bluetoothCommandSerializer, executorService, scheduledExecutorService, bluetoothCentral, peripheral, scanResult)
);
}
if (address != null && meshProxyMap.size() == 1) {
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyStateMachine.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyStateMachine.java
index e41307ef0..04abf4a25 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyStateMachine.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/BluetoothMeshProxyStateMachine.java
@@ -31,11 +31,7 @@ import org.openremote.model.syslog.SyslogCategory;
import java.util.List;
import java.util.UUID;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
import java.util.function.Consumer;
import java.util.logging.Logger;
@@ -53,7 +49,8 @@ public class BluetoothMeshProxyStateMachine {
private final BluetoothCentralManager bluetoothCentral;
private volatile BluetoothPeripheral peripheral;
private final BluetoothPeripheralCallback peripheralCallback;
- private final ScheduledExecutorService executorService;
+ private final ExecutorService executorService;
+ private final ScheduledExecutorService scheduledExecutorService;
private volatile BluetoothMeshProxyRxCallback rxDataCallback;
private volatile Consumer<ConnectionStatus> statusConsumer;
private volatile BluetoothMeshProxyConnectCallback connectCallback;
@@ -80,11 +77,12 @@ public class BluetoothMeshProxyStateMachine {
private final FailedState failedState = new FailedState(this);
private volatile State state = startState;
- public BluetoothMeshProxyStateMachine(BluetoothMeshProxy proxy, BluetoothCentralManager bluetoothCentral, ScheduledExecutorService executorService, MainThreadManager commandSerializer, BluetoothPeripheral peripheral, BluetoothPeripheralCallback callback) {
+ public BluetoothMeshProxyStateMachine(BluetoothMeshProxy proxy, BluetoothCentralManager bluetoothCentral, ExecutorService executorService, ScheduledExecutorService scheduledExecutorService, MainThreadManager commandSerializer, BluetoothPeripheral peripheral, BluetoothPeripheralCallback callback) {
this.meshProxy = proxy;
this.bluetoothCentral = bluetoothCentral;
this.commandSerializer = commandSerializer;
this.executorService = executorService;
+ this.scheduledExecutorService = scheduledExecutorService;
this.peripheral = peripheral;
this.peripheralCallback = callback;
}
@@ -238,7 +236,7 @@ public class BluetoothMeshProxyStateMachine {
}
void startQueueWorker() {
- workerFuture = executorService.schedule(queueWorker, 0, TimeUnit.MILLISECONDS);
+ workerFuture = scheduledExecutorService.schedule(queueWorker, 0, TimeUnit.MILLISECONDS);
}
void stopQueueWorker() {
@@ -337,7 +335,7 @@ public class BluetoothMeshProxyStateMachine {
}
void startTimeout(int timeout) {
- timeoutFuture = executorService.schedule(() -> {
+ timeoutFuture = scheduledExecutorService.schedule(() -> {
onTimeout();
},
timeout, TimeUnit.MILLISECONDS
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/MeshManagerApi.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/MeshManagerApi.java
index 9d7d9808a..bc562e344 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/MeshManagerApi.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/MeshManagerApi.java
@@ -83,7 +83,7 @@ public class MeshManagerApi implements MeshMngrApi{
private byte[] mIncomingBuffer;
private int mIncomingBufferOffset;
- private final ScheduledExecutorService executorService;
+ private final ScheduledExecutorService scheduledExecutorService;
private final Runnable mProxyProtocolTimeoutRunnable = new Runnable() {
@Override
@@ -95,8 +95,8 @@ public class MeshManagerApi implements MeshMngrApi{
/**
* The mesh manager api constructor.
*/
- public MeshManagerApi(ScheduledExecutorService executorService) {
- this.executorService = executorService;
+ public MeshManagerApi(ScheduledExecutorService scheduledExecutorService) {
+ this.scheduledExecutorService = scheduledExecutorService;
// mHandler = new Handler(Looper.getMainLooper());
mMeshProvisioningHandler = new MeshProvisioningHandler(internalTransportCallbacks, internalMeshMgrCallbacks);
mMeshMessageHandler = new MeshMessageHandler(internalTransportCallbacks, networkLayerCallbacks, upperTransportLayerCallbacks);
@@ -185,7 +185,7 @@ public class MeshManagerApi implements MeshMngrApi{
private void scheduleTimeoutHandler() {
cancelTimeoutHandler();
- scheduledFuture = executorService.schedule(mProxyProtocolTimeoutRunnable, PROXY_SAR_TRANSFER_TIME_OUT, TimeUnit.MILLISECONDS);
+ scheduledFuture = scheduledExecutorService.schedule(mProxyProtocolTimeoutRunnable, PROXY_SAR_TRANSFER_TIME_OUT, TimeUnit.MILLISECONDS);
}
private void cancelTimeoutHandler() {
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendMultiDataSegmentCommand.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendMultiDataSegmentCommand.java
index 383d00a45..b86983134 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendMultiDataSegmentCommand.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendMultiDataSegmentCommand.java
@@ -26,7 +26,7 @@ import org.openremote.model.syslog.SyslogCategory;
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ExecutorService;
import java.util.logging.Logger;
public class SendMultiDataSegmentCommand implements SendDataCommand {
@@ -41,14 +41,14 @@ public class SendMultiDataSegmentCommand implements SendDataCommand {
private final BluetoothGattCharacteristic dataInCharacteristic;
private final BluetoothMeshProxySendDataCallback callback;
private final byte[] data;
- private final ScheduledExecutorService executorService;
+ private final ExecutorService executorService;
private final List<SendSingleDataSegmentCommand> commands;
private volatile SendSingleDataSegmentCommand currentCommand;
// Constructors ---------------------------------------------------------------------------
- public SendMultiDataSegmentCommand(BluetoothMeshProxy proxy, MainThreadManager commandSerializer, int mtuSize, ScheduledExecutorService executorService, BluetoothGattCharacteristic characteristic, byte[] data, BluetoothMeshProxySendDataCallback callback) {
+ public SendMultiDataSegmentCommand(BluetoothMeshProxy proxy, MainThreadManager commandSerializer, int mtuSize, ExecutorService executorService, BluetoothGattCharacteristic characteristic, byte[] data, BluetoothMeshProxySendDataCallback callback) {
this.meshProxy = proxy;
this.commandSerializer = commandSerializer;
this.dataInCharacteristic = characteristic;
@@ -92,7 +92,7 @@ public class SendMultiDataSegmentCommand implements SendDataCommand {
// Private Instance Methods ---------------------------------------------------------------
- private List<SendSingleDataSegmentCommand> createCommands(int mtuSize, ScheduledExecutorService executorService, BluetoothGattCharacteristic characteristic, byte[] data, BluetoothMeshProxySendDataCallback callback) {
+ private List<SendSingleDataSegmentCommand> createCommands(int mtuSize, ExecutorService executorService, BluetoothGattCharacteristic characteristic, byte[] data, BluetoothMeshProxySendDataCallback callback) {
int numOfSegments = (data.length / mtuSize) + ((data.length % mtuSize) > 0 ? 1 : 0);
List<SendSingleDataSegmentCommand> commandList = new ArrayList<>(numOfSegments);
@@ -110,4 +110,4 @@ public class SendMultiDataSegmentCommand implements SendDataCommand {
private synchronized void setCurrentCommand(SendSingleDataSegmentCommand command) {
this.currentCommand = command;
}
-}
\ No newline at end of file
+}
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendSingleDataSegmentCommand.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendSingleDataSegmentCommand.java
index cd828a0af..0a8d80cd2 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendSingleDataSegmentCommand.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/SendSingleDataSegmentCommand.java
@@ -24,10 +24,7 @@ import com.welie.blessed.BluetoothGattCharacteristic;
import com.welie.blessed.BluetoothPeripheral;
import org.openremote.model.syslog.SyslogCategory;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
import java.util.logging.Logger;
public class SendSingleDataSegmentCommand implements SendDataCommand {
@@ -40,7 +37,7 @@ public class SendSingleDataSegmentCommand implements SendDataCommand {
private final BluetoothGattCharacteristic dataInCharacteristic;
protected final BluetoothMeshProxySendDataCallback callback;
private final byte[] data;
- protected final ScheduledExecutorService executorService;
+ protected final ExecutorService executorService;
private final BluetoothMeshProxy meshProxy;
private final MainThreadManager commandSerializer;
private volatile boolean isWaitForCallback = false;
@@ -49,7 +46,7 @@ public class SendSingleDataSegmentCommand implements SendDataCommand {
// Constructors ---------------------------------------------------------------------------
- public SendSingleDataSegmentCommand(BluetoothMeshProxy proxy, MainThreadManager commandSerializer, ScheduledExecutorService executorService, BluetoothGattCharacteristic characteristic, byte[] data, BluetoothMeshProxySendDataCallback callback) {
+ public SendSingleDataSegmentCommand(BluetoothMeshProxy proxy, MainThreadManager commandSerializer, ExecutorService executorService, BluetoothGattCharacteristic characteristic, byte[] data, BluetoothMeshProxySendDataCallback callback) {
this.meshProxy = proxy;
this.commandSerializer = commandSerializer;
this.executorService = executorService;
@@ -131,4 +128,4 @@ public class SendSingleDataSegmentCommand implements SendDataCommand {
}
return builder.toString();
}
-}
\ No newline at end of file
+}
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowGenericOnOffModel.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowGenericOnOffModel.java
index 8387e1a8c..5df987964 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowGenericOnOffModel.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowGenericOnOffModel.java
@@ -27,6 +27,7 @@ import org.openremote.agent.protocol.bluetooth.mesh.transport.MeshMessage;
import org.openremote.model.syslog.SyslogCategory;
import java.util.Random;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.logging.Logger;
@@ -36,7 +37,7 @@ public class ShadowGenericOnOffModel extends ShadowMeshModel {
public static final Logger LOG = SyslogCategory.getLogger(SyslogCategory.PROTOCOL, ShadowGenericOnOffModel.class.getName());
- public ShadowGenericOnOffModel(ScheduledExecutorService executorService, BluetoothMeshNetwork network, ShadowMeshElement element, int appKeyIndex) {
+ public ShadowGenericOnOffModel(ExecutorService executorService, BluetoothMeshNetwork network, ShadowMeshElement element, int appKeyIndex) {
super(executorService, network, element, appKeyIndex);
}
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshElement.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshElement.java
index 0ac43d727..d0de5b8f8 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshElement.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshElement.java
@@ -27,6 +27,7 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.logging.Logger;
@@ -34,12 +35,12 @@ public class ShadowMeshElement {
public static final Logger LOG = SyslogCategory.getLogger(SyslogCategory.PROTOCOL, ShadowMeshElement.class.getName());
- private final ScheduledExecutorService executorService;
+ private final ExecutorService executorService;
private final BluetoothMeshNetwork meshNetwork;
private final int address;
private final Map<Integer, ShadowMeshModel> modelMap = new HashMap<>();
- public ShadowMeshElement(ScheduledExecutorService executorService, BluetoothMeshNetwork network, int address) {
+ public ShadowMeshElement(ExecutorService executorService, BluetoothMeshNetwork network, int address) {
this.executorService = executorService;
this.meshNetwork = network;
this.address = address;
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshModel.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshModel.java
index 2457fddf5..a04aad410 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshModel.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/ShadowMeshModel.java
@@ -24,6 +24,7 @@ import org.openremote.model.syslog.SyslogCategory;
import java.util.ArrayList;
import java.util.List;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Consumer;
import java.util.logging.Logger;
@@ -37,9 +38,9 @@ public abstract class ShadowMeshModel {
protected final BluetoothMeshNetwork meshNetwork;
protected int appKeyIndex;
private final List<Consumer<Object>> sensorValueConsumers = new ArrayList<>();
- protected final ScheduledExecutorService executorService;
+ protected final ExecutorService executorService;
- public ShadowMeshModel(ScheduledExecutorService executorService, BluetoothMeshNetwork network, ShadowMeshElement element, int appKeyIndex) {
+ public ShadowMeshModel(ExecutorService executorService, BluetoothMeshNetwork network, ShadowMeshElement element, int appKeyIndex) {
this.executorService = executorService;
this.meshNetwork = network;
this.element = element;
diff --git a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/transport/MeshTransport.java b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/transport/MeshTransport.java
index 4c7215a8f..1379ee4b4 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/transport/MeshTransport.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/bluetooth/mesh/transport/MeshTransport.java
@@ -28,10 +28,7 @@ import org.openremote.container.concurrent.ContainerScheduledExecutor;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
import java.util.logging.Logger;
/**
@@ -55,7 +52,7 @@ final class MeshTransport extends NetworkLayer {
*/
MeshTransport() {
super();
- executor = new ContainerScheduledExecutor("Bluetooth-Mesh Thread Pool", 2);
+ scheduledExecutor = new ContainerScheduledExecutor("Bluetooth-Mesh Thread Pool", 2);
initHandler();
}
@@ -64,24 +61,24 @@ final class MeshTransport extends NetworkLayer {
*
* @param node Mesh node
*/
- MeshTransport(final ProvisionedMeshNode node) {
+ MeshTransport(ScheduledExecutorService scheduledExecutorService, final ProvisionedMeshNode node) {
super();
// this.mContext = context;
this.mMeshNode = node;
- executor = new ContainerScheduledExecutor("Bluetooth-Mesh Thread Pool", 2);
+ this.scheduledExecutor = scheduledExecutorService;
initHandler();
}
- private final ScheduledThreadPoolExecutor executor;
+ private final ScheduledExecutorService scheduledExecutor;
private final List<Future<?>> tasks = new CopyOnWriteArrayList<>();
@Override
protected Future<?> startTask(Runnable runnable, Long delay) {
Future<?> task = null;
if (delay == null || delay == 0) {
- task = executor.submit(runnable);
+ task = scheduledExecutor.submit(runnable);
} else {
- task = executor.schedule(runnable, delay, TimeUnit.MILLISECONDS);
+ task = scheduledExecutor.schedule(runnable, delay, TimeUnit.MILLISECONDS);
}
tasks.add(task);
return task;
diff --git a/agent/src/main/java/org/openremote/agent/protocol/http/HTTPProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/http/HTTPProtocol.java
index 44a602cb7..4fb4ee2e7 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/http/HTTPProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/http/HTTPProtocol.java
@@ -464,7 +464,7 @@ public class HTTPProtocol extends AbstractProtocol<HTTPAgent, HTTPAgentLink> {
protected static void initClient() {
synchronized (client) {
if (client.get() == null) {
- client.set(createClient(org.openremote.container.Container.EXECUTOR_SERVICE));
+ client.set(createClient(org.openremote.container.Container.SCHEDULED_EXECUTOR));
}
}
}
@@ -489,7 +489,7 @@ public class HTTPProtocol extends AbstractProtocol<HTTPAgent, HTTPAgentLink> {
LOG.fine("Scheduling polling request '" + clientRequest + "' to execute every " + pollingMillis + " ms for attribute: " + attribute);
- return executorService.scheduleWithFixedDelay(() -> {
+ return scheduledExecutorService.scheduleWithFixedDelay(() -> {
try {
Pair<Boolean, Object> ignoreAndConverted = ProtocolUtil.doOutboundValueProcessing(
diff --git a/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOClient.java b/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOClient.java
index 695ee71ef..39599d63b 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOClient.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOClient.java
@@ -151,13 +151,15 @@ public abstract class AbstractNettyIOClient<T, U extends SocketAddress> implemen
protected Channel channel;
protected Bootstrap bootstrap;
protected EventLoopGroup workerGroup;
- protected ScheduledExecutorService executorService;
+ protected ExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected CompletableFuture<Void> connectRetry;
protected int connectTimeout = 5000;
protected Supplier<ChannelHandler[]> encoderDecoderProvider;
protected AbstractNettyIOClient() {
- this.executorService = Container.EXECUTOR_SERVICE;
+ this.executorService = Container.EXECUTOR;
+ this.scheduledExecutorService = Container.SCHEDULED_EXECUTOR;
}
@Override
@@ -227,7 +229,7 @@ public abstract class AbstractNettyIOClient<T, U extends SocketAddress> implemen
.onRetryScheduled((execution) ->
LOG.info("Re-connection scheduled in '" + execution.getDelay() + "' for: " + getClientUri()))
.onFailedAttempt((execution) -> {
- LOG.info("Connection attempt failed '" + execution.getAttemptCount() + "' for: " + getClientUri());
+ LOG.info("Connection attempt failed '" + execution.getAttemptCount() + "' for: " + getClientUri() + ", error=" + (execution.getLastException() != null ? execution.getLastException().getMessage() : null));
doDisconnect();
})
.withMaxRetries(Integer.MAX_VALUE)
@@ -277,15 +279,20 @@ public abstract class AbstractNettyIOClient<T, U extends SocketAddress> implemen
onConnectionStatusChanged(ConnectionStatus.DISCONNECTING);
}
- if (connectRetry != null) {
- connectRetry.cancel(true);
- connectRetry = null;
- }
+ try {
+ if (connectRetry != null) {
+ connectRetry.cancel(true);
+ connectRetry = null;
+ }
+ } catch (Exception ignored) {}
doDisconnect();
- if (workerGroup != null) {
- workerGroup.shutdownGracefully();
- workerGroup = null;
- }
+ try {
+ if (workerGroup != null) {
+ workerGroup.shutdownGracefully();
+ workerGroup = null;
+ }
+ } catch (Exception ignored) {}
+ bootstrap = null;
onConnectionStatusChanged(ConnectionStatus.DISCONNECTED);
}
@@ -481,19 +488,24 @@ public abstract class AbstractNettyIOClient<T, U extends SocketAddress> implemen
}
if (future instanceof ChannelFuture channelFuture) {
CompletableFuture<Void> completableFuture = new CompletableFuture<>();
- channelFuture.addListener(cf -> {
- if (cf.isCancelled()) {
- completableFuture.cancel(true);
- return;
- }
- if (cf.cause() != null) {
- completableFuture.completeExceptionally(cf.cause());
- } else if (!cf.isSuccess()) {
- completableFuture.completeExceptionally(new RuntimeException("Unknown connection failure occurred"));
- } else {
- completableFuture.complete(null);
- }
- });
+
+ try {
+ channelFuture.addListener(cf -> {
+ if (cf.isCancelled()) {
+ completableFuture.cancel(true);
+ return;
+ }
+ if (cf.cause() != null) {
+ completableFuture.completeExceptionally(cf.cause());
+ } else if (!cf.isSuccess()) {
+ completableFuture.completeExceptionally(new RuntimeException("Unknown connection failure occurred"));
+ } else {
+ completableFuture.complete(null);
+ }
+ });
+ } catch (Exception e) {
+ completableFuture.completeExceptionally(e);
+ }
return completableFuture;
}
throw new UnsupportedOperationException("Future must be a ChannelFuture or already a CompletableFuture");
diff --git a/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOServer.java b/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOServer.java
index 8839648fd..6bda3fe64 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOServer.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/io/AbstractNettyIOServer.java
@@ -33,6 +33,7 @@ import java.net.SocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
@@ -53,7 +54,8 @@ public abstract class AbstractNettyIOServer<T, U extends Channel, V extends Abst
protected final static int MAX_RECONNECT_DELAY_MILLIS = 60000;
protected final static int RECONNECT_BACKOFF_MULTIPLIER = 2;
protected static final Logger LOG = SyslogCategory.getLogger(PROTOCOL, AbstractNettyIOServer.class);
- protected final ScheduledExecutorService executorService;
+ protected final ExecutorService executorService;
+ protected final ScheduledExecutorService scheduledExecutorService;
protected int clientLimit = 0; // 0 means no limit
protected V bootstrap;
protected ConnectionStatus connectionStatus = ConnectionStatus.DISCONNECTED;
@@ -68,7 +70,8 @@ public abstract class AbstractNettyIOServer<T, U extends Channel, V extends Abst
protected int reconnectDelayMilliseconds = INITIAL_RECONNECT_DELAY_MILLIS;
public AbstractNettyIOServer() {
- this.executorService = Container.EXECUTOR_SERVICE;
+ this.executorService = Container.EXECUTOR;
+ this.scheduledExecutorService = Container.SCHEDULED_EXECUTOR;
}
@Override
@@ -431,7 +434,7 @@ public abstract class AbstractNettyIOServer<T, U extends Channel, V extends Abst
LOG.finest("Scheduling reconnection in '" + reconnectDelayMilliseconds + "' milliseconds: " + getSocketAddressString());
- reconnectTask = executorService.schedule(() -> {
+ reconnectTask = scheduledExecutorService.schedule(() -> {
synchronized (AbstractNettyIOServer.this) {
reconnectTask = null;
diff --git a/agent/src/main/java/org/openremote/agent/protocol/knx/KNXConnection.java b/agent/src/main/java/org/openremote/agent/protocol/knx/KNXConnection.java
index 3534d19da..eb60486dc 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/knx/KNXConnection.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/knx/KNXConnection.java
@@ -41,7 +41,7 @@ public class KNXConnection implements NetworkLinkListener, ProcessListener {
protected ScheduledFuture<?> reconnectTask;
protected int reconnectDelayMilliseconds = INITIAL_RECONNECT_DELAY_MILLIS;
protected final List<Consumer<ConnectionStatus>> connectionStatusConsumers = new ArrayList<>();
- protected final ScheduledExecutorService executorService;
+ protected final ScheduledExecutorService scheduledExecutorService;
protected final String gatewayAddress;
private final int gatewayPort;
private final boolean natMode;
@@ -58,7 +58,7 @@ public class KNXConnection implements NetworkLinkListener, ProcessListener {
public KNXConnection(String gatewayAddress, String bindAddress, Integer gatewayPort, String messageSourceAddress, boolean routingMode, boolean natMode) {
this.gatewayAddress = gatewayAddress;
- this.executorService = Container.EXECUTOR_SERVICE;
+ this.scheduledExecutorService = Container.SCHEDULED_EXECUTOR;
this.routingMode = routingMode;
this.bindAddress = bindAddress;
this.gatewayPort = gatewayPort;
@@ -341,7 +341,7 @@ public class KNXConnection implements NetworkLinkListener, ProcessListener {
LOG.finest("Scheduling reconnection in '" + reconnectDelayMilliseconds + "' milliseconds");
- reconnectTask = executorService.schedule(() -> {
+ reconnectTask = scheduledExecutorService.schedule(() -> {
synchronized (KNXConnection.this) {
reconnectTask = null;
// Attempt to reconnect if not disconnecting
diff --git a/agent/src/main/java/org/openremote/agent/protocol/mail/AbstractMailProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/mail/AbstractMailProtocol.java
index bccf2f3f8..8ce56e7dc 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/mail/AbstractMailProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/mail/AbstractMailProtocol.java
@@ -33,9 +33,9 @@ import org.openremote.model.mail.MailMessage;
import org.openremote.model.syslog.SyslogCategory;
import java.nio.file.Path;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.logging.Level;
@@ -45,7 +45,7 @@ import static org.openremote.model.syslog.SyslogCategory.PROTOCOL;
public abstract class AbstractMailProtocol<T extends AbstractMailAgent<T, U, V>, U extends AbstractMailProtocol<T, U, V>, V extends AgentLink<V>> extends AbstractProtocol<T, V> {
protected MailClient mailClient;
- protected ConcurrentMap<AttributeRef, Function<MailMessage, String>> attributeMessageProcessorMap = new ConcurrentHashMap<>();
+ protected Map<AttributeRef, Function<MailMessage, String>> attributeMessageProcessorMap = new ConcurrentHashMap<>();
protected static final Logger LOG = SyslogCategory.getLogger(PROTOCOL, AbstractMailProtocol.class);
protected static int INITIAL_CHECK_DELAY_SECONDS = 10;
@@ -64,7 +64,8 @@ public abstract class AbstractMailProtocol<T extends AbstractMailAgent<T, U, V>,
Optional<Boolean> startTLS = getAgent().getStartTLS();
MailClientBuilder clientBuilder = new MailClientBuilder(
- container.getExecutorService(),
+ container.getExecutor(),
+ container.getScheduledExecutor(),
getAgent().getProtocol().orElseThrow(),
getAgent().getHost().orElseThrow(),
getAgent().getPort().orElseThrow()
diff --git a/agent/src/main/java/org/openremote/agent/protocol/mail/MailClientBuilder.java b/agent/src/main/java/org/openremote/agent/protocol/mail/MailClientBuilder.java
index df8bb7db4..f103a3381 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/mail/MailClientBuilder.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/mail/MailClientBuilder.java
@@ -30,6 +30,7 @@ import java.nio.file.Path;
import java.util.Date;
import java.util.Objects;
import java.util.Properties;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicReference;
@@ -38,6 +39,7 @@ public class MailClientBuilder {
public static final int DEFAULT_CHECK_INTERVAL_SECONDS = 5 * 60;
protected static int MIN_CHECK_INTERVAL_SECONDS = 10;
protected static final AtomicReference<Client> jaxrsClient = new AtomicReference<>();
+ protected ExecutorService executorService;
protected ScheduledExecutorService scheduledExecutorService;
protected int checkInitialDelaySeconds = 0;
protected int checkIntervalSeconds = DEFAULT_CHECK_INTERVAL_SECONDS;
@@ -56,7 +58,8 @@ public class MailClientBuilder {
protected boolean startTls;
protected Properties properties = new Properties();
- public MailClientBuilder(ScheduledExecutorService scheduledExecutorService, String protocol, String host, int port) {
+ public MailClientBuilder(ExecutorService executorService, ScheduledExecutorService scheduledExecutorService, String protocol, String host, int port) {
+ this.executorService = executorService;
this.scheduledExecutorService = scheduledExecutorService;
this.protocol = protocol;
this.host = host;
@@ -209,7 +212,7 @@ public class MailClientBuilder {
if (oAuthGrant != null) {
synchronized (jaxrsClient) {
if (jaxrsClient.get() == null) {
- jaxrsClient.set(WebTargetBuilder.createClient(scheduledExecutorService));
+ jaxrsClient.set(WebTargetBuilder.createClient(executorService));
}
}
synchronized (this) {
diff --git a/agent/src/main/java/org/openremote/agent/protocol/mqtt/AbstractMQTT_IOClient.java b/agent/src/main/java/org/openremote/agent/protocol/mqtt/AbstractMQTT_IOClient.java
index f44433852..613c5708e 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/mqtt/AbstractMQTT_IOClient.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/mqtt/AbstractMQTT_IOClient.java
@@ -90,7 +90,7 @@ public abstract class AbstractMQTT_IOClient<S> implements IOClient<MQTTMessage<S
this.cleanSession = cleanSession;
this.usernamePassword = usernamePassword;
this.websocketURI = websocketURI;
- this.executorService = Container.EXECUTOR_SERVICE;
+ this.executorService = Container.SCHEDULED_EXECUTOR;
Mqtt3ClientBuilder builder = MqttClient.builder()
.useMqttVersion3()
diff --git a/agent/src/main/java/org/openremote/agent/protocol/simulator/SimulatorProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/simulator/SimulatorProtocol.java
index cfe8dda56..2dbd7d593 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/simulator/SimulatorProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/simulator/SimulatorProtocol.java
@@ -160,7 +160,7 @@ public class SimulatorProtocol extends AbstractProtocol<SimulatorAgent, Simulato
long nextRunRelative = nextRun - now;
LOG.fine("Next update for asset " + attributeRef.getId() + " for attribute " + attributeRef.getName() + " in " + nextRunRelative + " second(s)");
- return executorService.schedule(() -> {
+ return scheduledExecutorService.schedule(() -> {
LOG.fine("Updating asset " + attributeRef.getId() + " for attribute " + attributeRef.getName() + " with value " + nextDatapoint.value.toString());
try {
updateLinkedAttribute(attributeRef, nextDatapoint.value);
diff --git a/agent/src/main/java/org/openremote/agent/protocol/simulator/storage/StorageSimulatorProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/simulator/storage/StorageSimulatorProtocol.java
index 1ec5fa0d0..1714066b7 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/simulator/storage/StorageSimulatorProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/simulator/storage/StorageSimulatorProtocol.java
@@ -196,7 +196,7 @@ public class StorageSimulatorProtocol extends AbstractProtocol<StorageSimulatorA
}
protected ScheduledFuture<?> scheduleUpdate(String assetId) {
- return executorService.scheduleAtFixedRate(() -> {
+ return scheduledExecutorService.scheduleAtFixedRate(() -> {
try {
updateStorageAsset(assetId);
} catch (Exception e) {
diff --git a/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriConnection.java b/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriConnection.java
index 715411695..5c591fad8 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriConnection.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriConnection.java
@@ -5,7 +5,6 @@ import org.openremote.agent.protocol.tradfri.device.Gateway;
import org.openremote.agent.protocol.tradfri.device.Light;
import org.openremote.agent.protocol.tradfri.device.Plug;
import org.openremote.agent.protocol.tradfri.util.Credentials;
-
import org.openremote.model.asset.agent.ConnectionStatus;
import org.openremote.model.asset.impl.LightAsset;
import org.openremote.model.asset.impl.PlugAsset;
@@ -14,10 +13,9 @@ import org.openremote.model.syslog.SyslogCategory;
import org.openremote.model.util.ValueUtil;
import org.openremote.model.value.impl.ColourRGB;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.function.Consumer;
import java.util.ArrayList;
import java.util.List;
+import java.util.function.Consumer;
import java.util.logging.Logger;
import static org.openremote.agent.protocol.tradfri.TradfriLightAsset.convertBrightness;
@@ -38,11 +36,6 @@ public class TradfriConnection {
*/
protected final List<Consumer<ConnectionStatus>> connectionStatusConsumers = new ArrayList<>();
- /**
- * The executor service of the IKEA TRÅDFRI connection
- */
- protected final ScheduledExecutorService executorService;
-
/**
* The IP address of the gateway
*/
@@ -67,12 +60,10 @@ public class TradfriConnection {
* Construct the TradfriConnection class.
* @param gatewayIp the IP address of the gateway.
* @param securityCode the security code to connect to the gateway.
- * @param executorService the executor service.
*/
- public TradfriConnection(String gatewayIp, String securityCode, ScheduledExecutorService executorService) {
+ public TradfriConnection(String gatewayIp, String securityCode) {
this.gatewayIp = gatewayIp;
this.securityCode = securityCode;
- this.executorService = executorService;
}
/**
diff --git a/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriProtocol.java
index ade08923b..04acc2265 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/tradfri/TradfriProtocol.java
@@ -71,7 +71,7 @@ public class TradfriProtocol extends AbstractProtocol<TradfriAgent, DefaultAgent
String securityCode = agent.getSecurityCode().orElse("");
- tradfriConnection = new TradfriConnection(host, securityCode, executorService);
+ tradfriConnection = new TradfriConnection(host, securityCode);
tradfriConnection.addConnectionStatusConsumer(this::setConnectionStatus);
// Connect to the gateway
diff --git a/agent/src/main/java/org/openremote/agent/protocol/velbus/AbstractVelbusProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/velbus/AbstractVelbusProtocol.java
index 61ded7f38..a76b0efa5 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/velbus/AbstractVelbusProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/velbus/AbstractVelbusProtocol.java
@@ -78,7 +78,7 @@ public abstract class AbstractVelbusProtocol<S extends AbstractVelbusProtocol<S,
int timeInjectionSeconds = agent.getTimeInjectionInterval().orElse(DEFAULT_TIME_INJECTION_INTERVAL_SECONDS);
LOG.fine("Creating new VELBUS network instance for protocol instance: " + agent);
- network = new VelbusNetwork(messageProcessor, executorService, timeInjectionSeconds);
+ network = new VelbusNetwork(messageProcessor, scheduledExecutorService, timeInjectionSeconds);
network.connect();
network.addConnectionStatusConsumer(this::setConnectionStatus);
diff --git a/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketAgentProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketAgentProtocol.java
index 73fc1c524..b131c8887 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketAgentProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketAgentProtocol.java
@@ -174,7 +174,7 @@ public class WebsocketAgentProtocol extends AbstractNettyIOClientProtocol<Websoc
Runnable task = () -> doSubscriptions(clientHeaders, websocketSubscriptions);
addAttributeConnectedTask(attributeRef, task);
if (client.getConnectionStatus() == ConnectionStatus.CONNECTED) {
- executorService.schedule(task, 1000, TimeUnit.MILLISECONDS);
+ scheduledExecutorService.schedule(task, 1000, TimeUnit.MILLISECONDS);
}
});
@@ -195,7 +195,7 @@ public class WebsocketAgentProtocol extends AbstractNettyIOClientProtocol<Websoc
protected static void initClient() {
synchronized (resteasyClient) {
if (resteasyClient.get() == null) {
- resteasyClient.set(createClient(org.openremote.container.Container.EXECUTOR_SERVICE));
+ resteasyClient.set(createClient(org.openremote.container.Container.SCHEDULED_EXECUTOR));
}
}
}
@@ -204,12 +204,12 @@ public class WebsocketAgentProtocol extends AbstractNettyIOClientProtocol<Websoc
// Look for any subscriptions that need to be processed
if (protocolConnectedTasks != null) {
// Execute after a delay to ensure connection is properly initialised
- executorService.schedule(() -> protocolConnectedTasks.forEach(Runnable::run), CONNECTED_SEND_DELAY_MILLIS, TimeUnit.MILLISECONDS);
+ scheduledExecutorService.schedule(() -> protocolConnectedTasks.forEach(Runnable::run), CONNECTED_SEND_DELAY_MILLIS, TimeUnit.MILLISECONDS);
}
if (attributeConnectedTasks != null) {
// Execute after a delay to ensure connection is properly initialised
- executorService.schedule(() -> attributeConnectedTasks.forEach((ref, task) -> task.run()), CONNECTED_SEND_DELAY_MILLIS, TimeUnit.MILLISECONDS);
+ scheduledExecutorService.schedule(() -> attributeConnectedTasks.forEach((ref, task) -> task.run()), CONNECTED_SEND_DELAY_MILLIS, TimeUnit.MILLISECONDS);
}
}
diff --git a/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketIOClient.java b/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketIOClient.java
index 5be437d9d..2a27c887f 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketIOClient.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/websocket/WebsocketIOClient.java
@@ -20,9 +20,7 @@
package org.openremote.agent.protocol.websocket;
import io.netty.buffer.ByteBuf;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.EventLoopGroup;
+import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.MessageToMessageEncoder;
@@ -140,8 +138,14 @@ public class WebsocketIOClient<T> extends AbstractNettyIOClient<T, InetSocketAdd
@Override
protected Future<Void> startChannel() {
handshakeFuture = new CompletableFuture<>();
+ CompletableFuture<Void> channelFuture;
+ try {
+ channelFuture = toCompletableFuture(bootstrap.connect(new InetSocketAddress(host, port)));
+ } catch (Exception e) {
+ channelFuture = CompletableFuture.failedFuture(e);
+ }
return CompletableFuture.allOf(
- toCompletableFuture(bootstrap.connect(new InetSocketAddress(host, port))),
+ channelFuture,
handshakeFuture
);
}
@@ -249,7 +253,7 @@ public class WebsocketIOClient<T> extends AbstractNettyIOClient<T, InetSocketAdd
private void doPing(ChannelHandlerContext ctx) {
LOG.finest("Sending PING: " + getClientUri());
- pingFuture = executorService.schedule(() -> {
+ pingFuture = scheduledExecutorService.schedule(() -> {
ctx.fireExceptionCaught(new Exception("PING failed"));
}, PING_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
ctx.channel().writeAndFlush(new PingWebSocketFrame());
diff --git a/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveNetwork.java b/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveNetwork.java
index 469c09028..344d66d04 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveNetwork.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveNetwork.java
@@ -21,10 +21,10 @@ package org.openremote.agent.protocol.zwave;
import org.openremote.controller.exception.ConfigurationException;
import org.openremote.model.asset.Asset;
-import org.openremote.model.asset.impl.ThingAsset;
-import org.openremote.model.attribute.Attribute;
import org.openremote.model.asset.AssetTreeNode;
import org.openremote.model.asset.agent.ConnectionStatus;
+import org.openremote.model.asset.impl.ThingAsset;
+import org.openremote.model.attribute.Attribute;
import org.openremote.model.attribute.MetaItem;
import org.openremote.model.util.ValueUtil;
import org.openremote.model.value.MetaItemType;
@@ -34,19 +34,16 @@ import org.openremote.protocol.zwave.model.Controller;
import org.openremote.protocol.zwave.model.ZWEndPoint;
import org.openremote.protocol.zwave.model.ZWManufacturerID;
import org.openremote.protocol.zwave.model.ZWaveNode;
-import org.openremote.protocol.zwave.model.commandclasses.ZWCommandClass;
-import org.openremote.protocol.zwave.model.commandclasses.ZWCommandClassID;
-import org.openremote.protocol.zwave.model.commandclasses.ZWParameterByte;
-import org.openremote.protocol.zwave.model.commandclasses.ZWParameterInt;
-import org.openremote.protocol.zwave.model.commandclasses.ZWParameterItem;
-import org.openremote.protocol.zwave.model.commandclasses.ZWParameterShort;
+import org.openremote.protocol.zwave.model.commandclasses.*;
import org.openremote.protocol.zwave.model.commandclasses.channel.Channel;
import org.openremote.protocol.zwave.model.commandclasses.channel.value.*;
import org.openremote.protocol.zwave.port.ZWavePortConfiguration;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Consumer;
import java.util.logging.Level;
@@ -61,11 +58,9 @@ public class ZWaveNetwork {
private final Map<Consumer<Value>, ChannelConsumerLink> consumerLinkMap = new HashMap<>();
protected String serialPort;
protected ZWaveSerialIOClient ioClient;
- protected ScheduledExecutorService executorService;
- public ZWaveNetwork(String serialPort, ScheduledExecutorService executorService) {
+ public ZWaveNetwork(String serialPort) {
this.serialPort = serialPort;
- this.executorService = executorService;
}
public synchronized void connect() {
diff --git a/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveProtocol.java b/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveProtocol.java
index d0688eeb6..b6d149ce1 100644
--- a/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveProtocol.java
+++ b/agent/src/main/java/org/openremote/agent/protocol/zwave/ZWaveProtocol.java
@@ -81,7 +81,7 @@ public class ZWaveProtocol extends AbstractProtocol<ZWaveAgent, ZWaveAgentLink>
setConnectionStatus(ConnectionStatus.ERROR);
return;
}
- network = new ZWaveNetwork(serialPort, executorService);
+ network = new ZWaveNetwork(serialPort);
network.addConnectionStatusConsumer(this::setConnectionStatus);
network.connect();
}
diff --git a/balena/manager.Dockerfile b/balena/manager.Dockerfile
index 79125f9e1..cdc49bdbb 100644
--- a/balena/manager.Dockerfile
+++ b/balena/manager.Dockerfile
@@ -50,7 +50,6 @@ ENV OR_MAP_SETTINGS_PATH ${OR_MAP_SETTINGS_PATH:-/deployment/map/mapsettings.jso
ENV OR_MAP_TILESERVER_HOST ${OR_MAP_TILESERVER_HOST}
ENV OR_MAP_TILESERVER_PORT ${OR_MAP_TILESERVER_PORT:-8082}
ENV OR_MAP_TILESERVER_REQUEST_TIMEOUT ${OR_MAP_TILESERVER_REQUEST_TIMEOUT:-10000}
-ENV OR_SCHEDULED_TASKS_THREADS_MAX ${OR_SCHEDULED_TASKS_THREADS_MAX:-4}
ENV OR_RULE_EVENT_EXPIRES ${OR_RULE_EVENT_EXPIRES:-PT1H}
ENV OR_IDENTITY_PROVIDER ${OR_IDENTITY_PROVIDER:-keycloak}
ENV OR_IDENTITY_SESSION_MAX_MINUTES ${OR_IDENTITY_SESSION_MAX_MINUTES:-1440}
diff --git a/container/build.gradle b/container/build.gradle
index d68a80731..1ec78dca1 100644
--- a/container/build.gradle
+++ b/container/build.gradle
@@ -46,7 +46,6 @@ dependencies {
api "org.apache.camel:camel-snmp:$camelVersion"
api "org.apache.camel:camel-health:$camelVersion"
api "org.apache.camel:camel-management:$camelVersion"
- api "org.apache.camel:camel-micrometer:$camelVersion"
api "io.micrometer:micrometer-registry-prometheus:$micrometerVersion"
}
diff --git a/container/src/main/java/org/openremote/container/Container.java b/container/src/main/java/org/openremote/container/Container.java
index f369c287d..769d81976 100644
--- a/container/src/main/java/org/openremote/container/Container.java
+++ b/container/src/main/java/org/openremote/container/Container.java
@@ -27,14 +27,14 @@ import io.micrometer.core.instrument.binder.jvm.ExecutorServiceMetrics;
import io.micrometer.prometheus.PrometheusConfig;
import io.prometheus.client.CollectorRegistry;
import org.openremote.container.concurrent.ContainerScheduledExecutor;
+import org.openremote.container.concurrent.ContainerThreadFactory;
import org.openremote.container.util.LogUtil;
import org.openremote.model.ContainerService;
import org.openremote.model.util.TextUtil;
import org.openremote.model.util.ValueUtil;
import java.util.*;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.*;
import java.util.logging.Handler;
import java.util.logging.Logger;
import java.util.stream.Collectors;
@@ -53,13 +53,25 @@ import static org.openremote.container.util.MapAccess.getInteger;
* Access environment configuration through {@link #getConfig()} and the helper methods
* in {@link org.openremote.container.util.MapAccess}. Consider using {@link org.openremote.model.Container#OR_DEV_MODE}
* to distinguish between development and production environments.
+ * To execute tasks in a standard way two {@link ExecutorService}s are provided:
+ * <ul>
+ * <li>{@link #EXECUTOR} - A dynamic {@link ThreadPoolExecutor} with {@link #OR_EXECUTOR_THREADS_MIN} core
+ * threads and max pool size of {@link #OR_EXECUTOR_THREADS_MAX} for general task execution/li>
+ * <li>{@link #SCHEDULED_EXECUTOR} - A {@link ScheduledThreadPoolExecutor} which is a fixed thread pool of size
+ * {@link #OR_SCHEDULED_EXECUTOR_THREADS} for scheduled task execution</li>
+ * </ul>
*/
public class Container implements org.openremote.model.Container {
public static final System.Logger LOG = System.getLogger(Container.class.getName());
- public static ScheduledExecutorService EXECUTOR_SERVICE;
- public static final String OR_SCHEDULED_TASKS_THREADS_MAX = "OR_SCHEDULED_TASKS_THREADS_MAX";
- public static final int OR_SCHEDULED_TASKS_THREADS_MAX_DEFAULT = Math.max(Runtime.getRuntime().availableProcessors(), 2);
+ public static ScheduledExecutorService SCHEDULED_EXECUTOR;
+ public static ExecutorService EXECUTOR;
+ public static final String OR_SCHEDULED_EXECUTOR_THREADS = "OR_SCHEDULED_EXECUTOR_THREADS";
+ public static final int OR_SCHEDULED_EXECUTOR_THREADS_DEFAULT = Math.min(Runtime.getRuntime().availableProcessors(), 4);
+ public static final String OR_EXECUTOR_THREADS_MIN = "OR_EXECUTOR_THREADS_MIN";
+ public static final String OR_EXECUTOR_THREADS_MAX = "OR_EXECUTOR_THREADS_MAX";
+ public static final int OR_EXECUTOR_THREADS_MIN_DEFAULT = Math.min(Runtime.getRuntime().availableProcessors(), 8);
+ public static final int OR_EXECUTOR_THREADS_MAX_DEFAULT = Runtime.getRuntime().availableProcessors()*10;
protected final Map<String, String> config = new HashMap<>();
protected final boolean devMode;
protected MeterRegistry meterRegistry;
@@ -106,15 +118,20 @@ public class Container implements org.openremote.model.Container {
meterRegistry = new io.micrometer.prometheus.PrometheusMeterRegistry(PrometheusConfig.DEFAULT, io.prometheus.client.CollectorRegistry.defaultRegistry, Clock.SYSTEM);
}
- int scheduledTasksThreadsMax = getInteger(
+ int scheduledExecutorThreads = getInteger(
getConfig(),
- OR_SCHEDULED_TASKS_THREADS_MAX,
- OR_SCHEDULED_TASKS_THREADS_MAX_DEFAULT);
+ OR_SCHEDULED_EXECUTOR_THREADS,
+ OR_SCHEDULED_EXECUTOR_THREADS_DEFAULT);
- EXECUTOR_SERVICE = new ContainerScheduledExecutor("Scheduled task", scheduledTasksThreadsMax);
+ int executorThreadsMin = getInteger(getConfig(), OR_EXECUTOR_THREADS_MIN, OR_EXECUTOR_THREADS_MIN_DEFAULT);
+ int executorThreadsMax = getInteger(getConfig(), OR_EXECUTOR_THREADS_MAX, OR_EXECUTOR_THREADS_MAX_DEFAULT);
+
+ SCHEDULED_EXECUTOR = new ContainerScheduledExecutor("ContainerScheduledExecutor", scheduledExecutorThreads);
+ EXECUTOR = new ThreadPoolExecutor(executorThreadsMin, executorThreadsMax, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), new ContainerThreadFactory("ContainerExecutor"), new ThreadPoolExecutor.CallerRunsPolicy());
if (meterRegistry != null) {
- EXECUTOR_SERVICE = ExecutorServiceMetrics.monitor(meterRegistry, EXECUTOR_SERVICE, "ContainerExecutorService");
+ SCHEDULED_EXECUTOR = ExecutorServiceMetrics.monitor(meterRegistry, SCHEDULED_EXECUTOR, "ContainerScheduledExecutor");
+ EXECUTOR = ExecutorServiceMetrics.monitor(meterRegistry, EXECUTOR, "ContainerExecutor");
}
// Any log handlers of the root logger that are container services must be registered
@@ -191,7 +208,7 @@ public class Container implements org.openremote.model.Container {
try {
LOG.log(INFO, "Cancelling scheduled tasks");
- EXECUTOR_SERVICE.shutdown();
+ SCHEDULED_EXECUTOR.shutdown();
} catch (Exception e) {
LOG.log(WARNING, "Exception thrown whilst trying to stop scheduled tasks", e);
}
@@ -283,7 +300,12 @@ public class Container implements org.openremote.model.Container {
}
@Override
- public ScheduledExecutorService getExecutorService() {
- return EXECUTOR_SERVICE;
+ public ScheduledExecutorService getScheduledExecutor() {
+ return SCHEDULED_EXECUTOR;
+ }
+
+ @Override
+ public ExecutorService getExecutor() {
+ return EXECUTOR;
}
}
diff --git a/container/src/main/java/org/openremote/container/concurrent/ContainerExecutor.java b/container/src/main/java/org/openremote/container/concurrent/ContainerExecutor.java
deleted file mode 100644
index 2be79d8d6..000000000
--- a/container/src/main/java/org/openremote/container/concurrent/ContainerExecutor.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright 2017, OpenRemote Inc.
- *
- * See the CONTRIBUTORS.txt file in the distribution for a
- * full listing of individual contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package org.openremote.container.concurrent;
-
-import java.util.concurrent.*;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * Thread pool that adds logging for tasks that throw exceptions
- */
-public class ContainerExecutor extends ThreadPoolExecutor {
-
- protected static final Logger LOG = Logger.getLogger(ContainerExecutor.class.getName());
- protected String name;
-
- /**
- * @param blockingQueueCapacity Set to <code>-1</code> if a {@link SynchronousQueue} should be used.
- */
- public ContainerExecutor(String name,
- int corePoolSize,
- int maximumPoolSize,
- long keepAliveSeconds,
- int blockingQueueCapacity,
- RejectedExecutionHandler rejectedExecutionHandler) {
- super(
- corePoolSize,
- maximumPoolSize,
- keepAliveSeconds,
- TimeUnit.SECONDS,
- blockingQueueCapacity == -1 ? new SynchronousQueue<>() : new ArrayBlockingQueue<>(blockingQueueCapacity),
- new ContainerThreadFactory(name),
- // Wrap rejected handler to add logging
- (r, executor) -> {
- // Log and discard
- LOG.fine("Container thread pool '" + executor + "' rejected execution of " + r);
- rejectedExecutionHandler.rejectedExecution(r, executor);
- }
- );
-
- this.name = name;
- }
-
- @Override
- protected void afterExecute(Runnable runnable, Throwable throwable) {
- super.afterExecute(runnable, throwable);
- logExceptionCause(runnable, throwable);
- }
-
- protected static void logExceptionCause(Runnable runnable, Throwable throwable) {
- if (throwable != null) {
- Throwable cause = unwrap(throwable);
- if (cause instanceof InterruptedException) {
- // Ignore this, might happen when we shutdownNow() the executor. We can't
- // log at this point as the logging system might be stopped already.
- return;
- }
- LOG.log(Level.WARNING, "Thread terminated unexpectedly executing: " +runnable.getClass(), throwable);
- }
- }
-
- protected static Throwable unwrap(Throwable throwable) throws IllegalArgumentException {
- if (throwable == null) {
- throw new IllegalArgumentException("Cannot unwrap null throwable");
- }
- for (Throwable current = throwable; current != null; current = current.getCause()) {
- throwable = current;
- }
- return throwable;
- }
-
- @Override
- public String toString() {
- return name + ":" + super.toString();
- }
-}
diff --git a/container/src/main/java/org/openremote/container/message/MessageBrokerService.java b/container/src/main/java/org/openremote/container/message/MessageBrokerService.java
index b9ce12033..ff2faf71f 100644
--- a/container/src/main/java/org/openremote/container/message/MessageBrokerService.java
+++ b/container/src/main/java/org/openremote/container/message/MessageBrokerService.java
@@ -19,8 +19,6 @@
*/
package org.openremote.container.message;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.binder.jvm.ExecutorServiceMetrics;
import org.apache.camel.FluentProducerTemplate;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.DefaultErrorHandlerBuilder;
@@ -37,11 +35,8 @@ import org.apache.camel.spi.StreamCachingStrategy;
import org.apache.camel.spi.ThreadPoolFactory;
import org.apache.camel.spi.ThreadPoolProfile;
import org.apache.camel.support.DefaultRegistry;
+import org.apache.camel.support.DefaultThreadPoolFactory;
import org.apache.camel.support.SimpleRegistry;
-import org.apache.camel.util.StringHelper;
-import org.apache.camel.util.concurrent.CamelThreadFactory;
-import org.openremote.container.concurrent.ContainerExecutor;
-import org.openremote.container.concurrent.ContainerScheduledExecutor;
import org.openremote.model.Container;
import org.openremote.model.ContainerService;
@@ -49,8 +44,6 @@ import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Logger;
public class MessageBrokerService implements ContainerService {
@@ -67,53 +60,22 @@ public class MessageBrokerService implements ContainerService {
return PRIORITY;
}
- @SuppressWarnings("deprecation")
@Override
public void init(Container container) throws Exception {
-
- MeterRegistry meterRegistry = container.getMeterRegistry();
final ExecutorServiceManager executorServiceManager = context.getExecutorServiceManager();
// Not using InstrumentedThreadPoolFactory directly as it only uses the ThreadPoolProfile ID for naming
- ThreadPoolFactory threadPoolFactory = new ThreadPoolFactory() {
- private static final AtomicLong COUNTER = new AtomicLong();
+ ThreadPoolFactory threadPoolFactory = new DefaultThreadPoolFactory() {
+ @Override
+ public ExecutorService newThreadPool(ThreadPoolProfile profile, ThreadFactory threadFactory) {
- @Override
- public ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
- // This is an unlimited pool used probably only by multicast aggregation
- ExecutorService executorService = new ContainerExecutor(
- getExecutorName("CachedPool", threadFactory),
- 1,
- Integer.MAX_VALUE,
- 10,
- -1,
- new ThreadPoolExecutor.CallerRunsPolicy());
-
-// Disabled as not very useful for SEDA components
-// if (meterRegistry != null) {
-// executorService = ExecutorServiceMetrics.monitor(meterRegistry, executorService, name("instrumented-delegate-"));
-// }
+ ExecutorService executorService;
- return executorService;
- }
-
- @Override
- public ExecutorService newThreadPool(ThreadPoolProfile profile, ThreadFactory threadFactory) {
- // This pool is used by SEDA consumers, so the endpoint parameters define the pool and queue sizes
- ExecutorService executorService = new ContainerExecutor(
- getExecutorName("Pool", threadFactory),
- profile.getPoolSize(),
- profile.getMaxPoolSize(),
- profile.getKeepAliveTime(),
- profile.getMaxQueueSize(),
- profile.getRejectedExecutionHandler()
- );
-
- // Want to instrument pools that use defaultThreadPool profile (ProducerTemplate and multiple consumer SEDA endpoints)
- if (meterRegistry != null && profile.isDefaultProfile() != null && profile.isDefaultProfile()) {
- String name = getExecutorName("Pool", threadFactory);
- name = "Pool".equals(name) ? profile.getId() : name;
- executorService = ExecutorServiceMetrics.monitor(meterRegistry, executorService, name(name));
+ // Force any endpoints that use the default profile to use the container executor to reduce thread count
+ if (profile.isDefaultProfile()) {
+ executorService = container.getExecutor();
+ } else {
+ executorService = super.newThreadPool(profile, threadFactory);
}
return executorService;
@@ -121,37 +83,20 @@ public class MessageBrokerService implements ContainerService {
@Override
public ScheduledExecutorService newScheduledThreadPool(ThreadPoolProfile profile, ThreadFactory threadFactory) {
- ScheduledExecutorService scheduledExecutorService = new ContainerScheduledExecutor(
- getExecutorName("ScheduledPool", threadFactory),
- profile.getPoolSize(), profile.getRejectedExecutionHandler()
- );
-
-// Disabled as not very useful for SEDA components
-// if (meterRegistry != null) {
-// String name = getExecutorName("", threadFactory);
-// name = "ScheduledPool".equals(name) ? profile.getId() : name;
-// scheduledExecutorService = new TimedScheduledExecutorService(meterRegistry, scheduledExecutorService, name(name), Tags.empty());
-// }
-
- return scheduledExecutorService;
- }
+ ScheduledExecutorService scheduledExecutorService;
- protected String getExecutorName(String name, ThreadFactory threadFactory) {
- if (threadFactory instanceof CamelThreadFactory factory) {
- String camelName = factory.getName();
- camelName = camelName.contains("://") ? StringHelper.after(camelName, "://") : camelName;
- camelName = camelName.contains("?") ? StringHelper.before(camelName, "?") : camelName;
- name = name + "-" + camelName;
+ // Force any endpoints that use the default profile to use a single built in executor to avoid excessive thread creation
+ if (profile.isDefaultProfile()) {
+ scheduledExecutorService = container.getScheduledExecutor();
+ } else {
+ scheduledExecutorService = super.newScheduledThreadPool(profile, threadFactory);
}
- return name;
- }
- private String name(String prefix) {
- return prefix + COUNTER.incrementAndGet();
+ return scheduledExecutorService;
}
};
- executorServiceManager.setThreadNamePattern("#counter# #name#");
+ executorServiceManager.setThreadNamePattern("#name#-#counter#");
executorServiceManager.setThreadPoolFactory(threadPoolFactory);
// TODO might need this for errorhandler?
diff --git a/container/src/main/java/org/openremote/container/persistence/PersistenceService.java b/container/src/main/java/org/openremote/container/persistence/PersistenceService.java
index 218bc00a7..ee1b273fe 100644
--- a/container/src/main/java/org/openremote/container/persistence/PersistenceService.java
+++ b/container/src/main/java/org/openremote/container/persistence/PersistenceService.java
@@ -433,11 +433,7 @@ public class PersistenceService implements ContainerService, Consumer<Persistenc
} catch (Exception ex) {
if (tx != null && tx.isActive()) {
try {
- if (LOG.isLoggable(Level.FINER)) {
- LOG.log(Level.FINE, "Rolling back failed transaction, cause follows", ex);
- } else {
- LOG.log(Level.FINE, "Rolling back failed transaction");
- }
+ LOG.log(Level.FINE, "Rolling back failed transaction");
tx.rollback();
} catch (RuntimeException rbEx) {
LOG.log(Level.SEVERE, "Rollback of transaction failed!", rbEx);
diff --git a/manager/Dockerfile b/manager/Dockerfile
index 6be99eff7..cfbdf4eaa 100644
--- a/manager/Dockerfile
+++ b/manager/Dockerfile
@@ -50,7 +50,6 @@ ENV OR_MAP_SETTINGS_PATH ${OR_MAP_SETTINGS_PATH:-/deployment/map/mapsettings.jso
ENV OR_MAP_TILESERVER_HOST ${OR_MAP_TILESERVER_HOST}
ENV OR_MAP_TILESERVER_PORT ${OR_MAP_TILESERVER_PORT:-8082}
ENV OR_MAP_TILESERVER_REQUEST_TIMEOUT ${OR_MAP_TILESERVER_REQUEST_TIMEOUT:-10000}
-ENV OR_SCHEDULED_TASKS_THREADS_MAX ${OR_SCHEDULED_TASKS_THREADS_MAX:-4}
ENV OR_RULE_EVENT_EXPIRES ${OR_RULE_EVENT_EXPIRES:-PT1H}
ENV OR_IDENTITY_PROVIDER ${OR_IDENTITY_PROVIDER:-keycloak}
ENV OR_IDENTITY_SESSION_MAX_MINUTES ${OR_IDENTITY_SESSION_MAX_MINUTES:-1440}
@@ -78,5 +77,5 @@ ADD deployment /deployment
EXPOSE 8080
EXPOSE 1883
-HEALTHCHECK --interval=3s --timeout=60s --start-period=30s --retries=120 CMD curl --fail --silent http://localhost:8080 || exit 1
+HEALTHCHECK --interval=5s --timeout=60s --start-period=5s --retries=120 CMD curl --fail --silent http://localhost:8080 || exit 1
ENTRYPOINT java $OR_JAVA_OPTS -cp /opt/app/lib/*:/deployment/manager/extensions/* org.openremote.manager.Main
diff --git a/manager/src/main/java/org/openremote/manager/agent/AgentResourceImpl.java b/manager/src/main/java/org/openremote/manager/agent/AgentResourceImpl.java
index 791229ff2..c922e4a5d 100644
--- a/manager/src/main/java/org/openremote/manager/agent/AgentResourceImpl.java
+++ b/manager/src/main/java/org/openremote/manager/agent/AgentResourceImpl.java
@@ -19,6 +19,7 @@
*/
package org.openremote.manager.agent;
+import jakarta.ws.rs.*;
import org.openremote.container.timer.TimerService;
import org.openremote.container.util.CodecUtil;
import org.openremote.manager.asset.AssetStorageService;
@@ -34,15 +35,14 @@ import org.openremote.model.http.RequestParams;
import org.openremote.model.util.TextUtil;
import org.openremote.model.util.ValueUtil;
-import jakarta.ws.rs.*;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -54,13 +54,13 @@ public class AgentResourceImpl extends ManagerWebResource implements AgentResour
private static final Logger LOG = Logger.getLogger(AgentResourceImpl.class.getName());
protected final AgentService agentService;
protected final AssetStorageService assetStorageService;
- protected final ScheduledExecutorService executorService;
+ protected final ExecutorService executorService;
public AgentResourceImpl(TimerService timerService,
ManagerIdentityService identityService,
AssetStorageService assetStorageService,
AgentService agentService,
- ScheduledExecutorService executorService) {
+ ExecutorService executorService) {
super(timerService, identityService);
this.agentService = agentService;
this.assetStorageService = assetStorageService;
diff --git a/manager/src/main/java/org/openremote/manager/agent/AgentService.java b/manager/src/main/java/org/openremote/manager/agent/AgentService.java
index 72b1aa2a7..2ebd74362 100644
--- a/manager/src/main/java/org/openremote/manager/agent/AgentService.java
+++ b/manager/src/main/java/org/openremote/manager/agent/AgentService.java
@@ -36,7 +36,10 @@ import org.openremote.model.PersistenceEvent;
import org.openremote.model.asset.Asset;
import org.openremote.model.asset.AssetFilter;
import org.openremote.model.asset.AssetTreeNode;
-import org.openremote.model.asset.agent.*;
+import org.openremote.model.asset.agent.Agent;
+import org.openremote.model.asset.agent.AgentLink;
+import org.openremote.model.asset.agent.ConnectionStatus;
+import org.openremote.model.asset.agent.Protocol;
import org.openremote.model.attribute.*;
import org.openremote.model.protocol.ProtocolAssetDiscovery;
import org.openremote.model.protocol.ProtocolAssetImport;
@@ -52,8 +55,8 @@ import org.openremote.model.util.TextUtil;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.logging.Level;
@@ -84,22 +87,6 @@ import static org.openremote.model.value.MetaItemType.AGENT_LINK;
*/
public class AgentService extends RouteBuilder implements ContainerService {
- /**
- * This is used as source of events generated by this service
- */
- protected static class AgentSourceRef extends AttributeRef {
- public AgentSourceRef(String id, String name) {
- super(id, name);
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (!(o instanceof AttributeRef that)) return false;
- return id.equals(that.getId()) && name.equals(that.getName());
- }
- }
-
protected class AgentProtocolAssetService implements ProtocolAssetService {
protected Agent<?,?,?> agent;
@@ -203,7 +190,7 @@ public class AgentService extends RouteBuilder implements ContainerService {
protected AssetStorageService assetStorageService;
protected ClientEventService clientEventService;
protected GatewayService gatewayService;
- protected ScheduledExecutorService executorService;
+ protected ExecutorService executorService;
protected Map<String, Agent<?, ?, ?>> agentMap;
protected final Map<String, Future<Void>> agentDiscoveryImportFutureMap = new ConcurrentHashMap<>();
protected final Map<String, Protocol<?>> protocolInstanceMap = new ConcurrentHashMap<>();
@@ -225,7 +212,7 @@ public class AgentService extends RouteBuilder implements ContainerService {
assetStorageService = container.getService(AssetStorageService.class);
clientEventService = container.getService(ClientEventService.class);
gatewayService = container.getService(GatewayService.class);
- executorService = container.getExecutorService();
+ executorService = container.getExecutor();
if (initDone) {
return;
@@ -237,12 +224,12 @@ public class AgentService extends RouteBuilder implements ContainerService {
container.getService(ManagerIdentityService.class),
assetStorageService,
this,
- container.getExecutorService())
+ container.getExecutor())
);
assetProcessingService.addEventInterceptor(this::onAttributeEventIntercepted);
- clientEventService.addInternalSubscription(AttributeEvent.class, new AssetFilter<AttributeEvent>().setAssetClasses(Collections.singletonList(Agent.class)), this::onAgentAttributeEvent);
+ clientEventService.addSubscription(AttributeEvent.class, new AssetFilter<AttributeEvent>().setAssetClasses(Collections.singletonList(Agent.class)), this::onAgentAttributeEvent);
initDone = true;
}
@@ -401,7 +388,7 @@ public class AgentService extends RouteBuilder implements ContainerService {
protected void sendAttributeEvent(AttributeEvent event) {
// Set the source so we can ignore the intercept when the event comes back through the chain
- assetProcessingService.sendAttributeEvent(event, new AgentSourceRef(event.getId(), event.getName()));
+ assetProcessingService.sendAttributeEvent(event, getClass().getSimpleName());
}
protected void doAgentInit(Agent<?,?,?> agent) {
@@ -553,10 +540,8 @@ public class AgentService extends RouteBuilder implements ContainerService {
protected boolean onAttributeEventIntercepted(EntityManager em,
AttributeEvent event) throws AssetProcessingException {
- AgentSourceRef sourceRef = getSourceRef(event);
-
- // Don't intercept an event that was generated by this service for the same attribute
- if (sourceRef != null && sourceRef.equals(event.getRef())) {
+ // Don't intercept an event that was generated by this service
+ if (getClass().getSimpleName().equals(event.getSource())) {
return false;
}
@@ -637,13 +622,6 @@ public class AgentService extends RouteBuilder implements ContainerService {
}
}
- protected static AgentSourceRef getSourceRef(AttributeEvent event) {
- if (event.getSource() instanceof AgentSourceRef agentSourceRef) {
- return agentSourceRef;
- }
- return null;
- }
-
/**
* Gets all agent link attributes and their linked agent and groups them by agent
*/
diff --git a/manager/src/main/java/org/openremote/manager/asset/AssetProcessingService.java b/manager/src/main/java/org/openremote/manager/asset/AssetProcessingService.java
index f06053a73..50eb09784 100644
--- a/manager/src/main/java/org/openremote/manager/asset/AssetProcessingService.java
+++ b/manager/src/main/java/org/openremote/manager/asset/AssetProcessingService.java
@@ -22,6 +22,7 @@ package org.openremote.manager.asset;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.Timer;
import jakarta.validation.ConstraintViolation;
import org.apache.camel.Exchange;
import org.apache.camel.builder.RouteBuilder;
@@ -29,7 +30,6 @@ import org.apache.camel.builder.RouteConfigurationBuilder;
import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.persistence.PersistenceService;
import org.openremote.container.timer.TimerService;
-import org.openremote.container.util.MapAccess;
import org.openremote.manager.agent.AgentService;
import org.openremote.manager.datapoint.AssetDatapointService;
import org.openremote.manager.event.AttributeEventInterceptor;
@@ -51,10 +51,10 @@ import org.openremote.model.value.MetaItemType;
import java.time.Instant;
import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionException;
-import java.util.stream.IntStream;
-import static org.openremote.manager.system.HealthService.OR_CAMEL_ROUTE_METRIC_PREFIX;
import static org.openremote.model.attribute.AttributeWriteFailure.*;
/**
@@ -85,15 +85,8 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
public static final String ATTRIBUTE_EVENT_ROUTE_CONFIG_ID = "attributeEvent";
public static final int PRIORITY = AssetStorageService.PRIORITY + 1000;
- public static final String ATTRIBUTE_EVENT_ROUTER_QUEUE = "seda://AttributeEventRouter?waitForTaskToComplete=IfReplyExpected&timeout=10000&purgeWhenStopping=false&discardIfNoConsumers=false&size=10000";
- public static final String OR_ATTRIBUTE_EVENT_THREADS = "OR_ATTRIBUTE_EVENT_THREADS";
- public static final int OR_ATTRIBUTE_EVENT_THREADS_DEFAULT = Runtime.getRuntime().availableProcessors();
- protected static final String EVENT_ROUTE_COUNT_HEADER = "EVENT_ROUTE_COUNT_HEADER";
- protected static final String EVENT_PROCESSOR_URI_PREFIX = "seda://AttributeEventProcessor";
- protected static final String EVENT_PROCESSOR_URI_SUFFIX = "?size=3000&timeout=10000";
- public static final String EVENT_PROCESSOR_ROUTE_ID_PREFIX = "AttributeEvent-Processor";
+ public static final String ATTRIBUTE_EVENT_PROCESSOR = "direct://AttributeEventProcessor";
private static final System.Logger LOG = System.getLogger(AssetProcessingService.class.getName());
-
final protected List<AttributeEventInterceptor> eventInterceptors = new ArrayList<>();
protected TimerService timerService;
protected ManagerIdentityService identityService;
@@ -108,8 +101,10 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
protected ClientEventService clientEventService;
// Used in testing to detect if initial/startup processing has completed
protected long lastProcessedEventTimestamp = System.currentTimeMillis();
- protected int eventProcessingThreadCount;
- protected Counter queueFullCounter;
+ protected ExecutorService executorService;
+ protected MeterRegistry meterRegistry;
+ protected Timer eventTimer;
+ protected Map<String, Counter> eventCounters;
@Override
public int getPriority() {
@@ -129,13 +124,9 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
assetAttributeLinkingService = container.getService(AttributeLinkingService.class);
messageBrokerService = container.getService(MessageBrokerService.class);
clientEventService = container.getService(ClientEventService.class);
- MeterRegistry meterRegistry = container.getMeterRegistry();
+ executorService = container.getExecutor();
EventSubscriptionAuthorizer assetEventAuthorizer = AssetStorageService.assetInfoAuthorizer(identityService, assetStorageService);
- if (meterRegistry != null) {
- queueFullCounter = meterRegistry.counter(OR_CAMEL_ROUTE_METRIC_PREFIX + "_failed_queue_full", Tags.empty());
- }
-
clientEventService.addSubscriptionAuthorizer((requestedRealm, auth, subscription) -> {
if (!subscription.isEventType(AttributeEvent.class)) {
return false;
@@ -208,16 +199,6 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
return true;
});
- // Get dynamic route count for event processing (multithreaded event processing but guaranteeing events for the same asset end up in the same route)
- eventProcessingThreadCount = MapAccess.getInteger(container.getConfig(), OR_ATTRIBUTE_EVENT_THREADS, OR_ATTRIBUTE_EVENT_THREADS_DEFAULT);
- if (eventProcessingThreadCount < 1) {
- LOG.log(System.Logger.Level.WARNING, OR_ATTRIBUTE_EVENT_THREADS + " value " + eventProcessingThreadCount + " is less than 1; forcing to 1");
- eventProcessingThreadCount = 1;
- } else if (eventProcessingThreadCount > 20) {
- LOG.log(System.Logger.Level.WARNING, OR_ATTRIBUTE_EVENT_THREADS + " value " + eventProcessingThreadCount + " is greater than max value of 20; forcing to 20");
- eventProcessingThreadCount = 20;
- }
-
// Add exception handling for attribute event processing that logs queue full exceptions and counts them
messageBrokerService.getContext().addRoutesConfigurations(new RouteConfigurationBuilder() {
@SuppressWarnings("unchecked")
@@ -233,9 +214,6 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
if (exception instanceof RejectedExecutionException || (exception instanceof IllegalStateException illegalStateException && "Queue full".equals(illegalStateException.getMessage()))) {
exception = new AssetProcessingException(QUEUE_FULL, "Queue for this message is full");
- if (queueFullCounter != null) {
- queueFullCounter.increment();
- }
}
// Make the exception available if MEP is InOut
@@ -252,7 +230,6 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
.append(body);
if (exception instanceof AssetProcessingException processingException) {
- error.append(" ").append(" - ").append(processingException.getMessage());
if (processingException.getReason() == ASSET_NOT_FOUND) {
LOG.log(System.Logger.Level.DEBUG, error::toString);
} else {
@@ -266,6 +243,12 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
});
messageBrokerService.getContext().addRoutes(this);
+
+ if (container.getMeterRegistry() != null) {
+ meterRegistry = container.getMeterRegistry();
+ eventCounters = new ConcurrentHashMap<>();
+ eventTimer = meterRegistry.timer("or.attributes", Tags.empty());
+ }
}
@Override
@@ -276,24 +259,21 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
public void stop(Container container) throws Exception {
}
- @SuppressWarnings({"rawtypes", "unchecked"})
@Override
public void configure() throws Exception {
// All user authorisation checks MUST have been carried out before events reach this queue
-
- // Router is responsible for routing events to the same processor for a given asset ID, this allows for
- // multithreaded processing across assets
- from(ATTRIBUTE_EVENT_ROUTER_QUEUE)
- .routeId("AttributeEvent-Router")
+ from(ATTRIBUTE_EVENT_PROCESSOR)
+ .routeId("AttributeEvent-Processor")
.routeConfigurationId(ATTRIBUTE_EVENT_ROUTE_CONFIG_ID)
+ .threads().executorService(executorService)
.process(exchange -> {
AttributeEvent event = exchange.getIn().getBody(AttributeEvent.class);
if (event.getId() == null || event.getId().isEmpty())
- return; // Ignore events with no asset ID
+ throw new AssetProcessingException(ASSET_ID_MISSING);
if (event.getName() == null || event.getName().isEmpty())
- return; // Ignore events with no attribute name
+ throw new AssetProcessingException(ATTRIBUTE_NAME_MISSING);
if (event.getTimestamp() <= 0) {
// Set timestamp if not set
@@ -303,24 +283,27 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
event.setTimestamp(timerService.getCurrentTimeMillis());
}
- exchange.getIn().setHeader(EVENT_ROUTE_COUNT_HEADER, getEventProcessingRouteNumber(event.getId()));
- })
- .toD(EVENT_PROCESSOR_URI_PREFIX + "${header." + EVENT_ROUTE_COUNT_HEADER + "}");
-
- // Create the event processor routes
- IntStream.rangeClosed(1, eventProcessingThreadCount).forEach(processorCount -> {
- String camelRouteURI = getEventProcessingRouteURI(processorCount);
-
- from(camelRouteURI)
- .routeId(EVENT_PROCESSOR_ROUTE_ID_PREFIX + processorCount)
- .routeConfigurationId(ATTRIBUTE_EVENT_ROUTE_CONFIG_ID)
- .process(exchange -> {
- AttributeEvent event = exchange.getIn().getBody(AttributeEvent.class);
- LOG.log(System.Logger.Level.TRACE, () -> ">>> Attribute event processing start: processor=" + processorCount + ", event=" + event);
- boolean processed = processAttributeEvent(event);
- exchange.getIn().setBody(processed);
- });
- });
+ LOG.log(System.Logger.Level.TRACE, () -> ">>> Attribute event processing start: " + event);
+ Counter counter = getEventCounter(event.getSource());
+ if (counter != null) {
+ counter.increment();
+ }
+
+ boolean processed = eventTimer != null ?
+ eventTimer.record(() -> processAttributeEvent(event)) :
+ processAttributeEvent(event);
+
+ exchange.getIn().setBody(processed);
+ });
+ }
+
+ protected Counter getEventCounter(String source) {
+ if (eventCounters == null) {
+ return null;
+ }
+ String sourceStr = source == null ? "none" : source;
+ return eventCounters.computeIfAbsent(sourceStr, eventSource ->
+ meterRegistry.counter("or.attributes", Tags.of("source", eventSource)));
}
public void addEventInterceptor(AttributeEventInterceptor eventInterceptor) {
@@ -329,16 +312,16 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
}
/**
- * Send internal attribute change events into the {@link #ATTRIBUTE_EVENT_ROUTER_QUEUE}.
+ * Send internal attribute change events into the {@link #ATTRIBUTE_EVENT_PROCESSOR}.
*/
public void sendAttributeEvent(AttributeEvent attributeEvent) {
sendAttributeEvent(attributeEvent, null);
}
/**
- * Send internal attribute change events into the {@link #ATTRIBUTE_EVENT_ROUTER_QUEUE}.
+ * Send internal attribute change events into the {@link #ATTRIBUTE_EVENT_PROCESSOR}.
*/
- public void sendAttributeEvent(AttributeEvent attributeEvent, Object source) {
+ public void sendAttributeEvent(AttributeEvent attributeEvent, String source) {
attributeEvent.setSource(source);
// Set event source time if not already set
@@ -347,7 +330,7 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
}
messageBrokerService.getFluentProducerTemplate()
.withBody(attributeEvent)
- .to(ATTRIBUTE_EVENT_ROUTER_QUEUE)
+ .to(ATTRIBUTE_EVENT_PROCESSOR)
.asyncSend();
}
@@ -357,45 +340,45 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
*/
protected boolean processAttributeEvent(AttributeEvent event) throws AssetProcessingException {
- long startMillis = System.currentTimeMillis();
- // Need to record time here otherwise an infinite loop generated inside one of the interceptors means the timestamp
- // is not updated so tests can't then detect the problem.
- lastProcessedEventTimestamp = startMillis;
+ return assetStorageService.withAssetLock(event.getId(),() -> {
- // TODO: Get asset lock so it cannot be modified during event processing
- persistenceService.doTransaction(em -> {
+ long startMillis = System.currentTimeMillis();
+ // Need to record time here otherwise an infinite loop generated inside one of the interceptors means the timestamp
+ // is not updated so tests can't then detect the problem.
+ lastProcessedEventTimestamp = startMillis;
- // TODO: Retrieve optimised DTO rather than whole asset
- Asset<?> asset = assetStorageService.find(em, event.getId(), true);
+ return persistenceService.doReturningTransaction(em -> {
+ // TODO: Retrieve optimised DTO rather than whole asset
+ Asset<?> asset = assetStorageService.find(em, event.getId(), true);
- if (asset == null) {
- throw new AssetProcessingException(ASSET_NOT_FOUND, "Asset may have been deleted before event could be processed or it never existed");
- }
+ if (asset == null) {
+ throw new AssetProcessingException(ASSET_NOT_FOUND, event.getId());
+ }
- Attribute<Object> attribute = asset.getAttribute(event.getName()).orElseThrow(() ->
- new AssetProcessingException(ATTRIBUTE_NOT_FOUND, "Attribute may have been deleted before event could be processed or it never existed"));
+ Attribute<Object> attribute = asset.getAttribute(event.getName()).orElseThrow(() ->
+ new AssetProcessingException(ATTRIBUTE_NOT_FOUND, event.getRef().toString()));
- // Type coercion
- Object value = event.getValue().map(eventValue -> {
- Class<?> attributeValueType = attribute.getTypeClass();
- return ValueUtil.getValueCoerced(eventValue, attributeValueType).orElseThrow(() -> {
- String msg = "Event processing failed unable to coerce value into the correct value type: realm=" + event.getRealm() + ", attribute=" + event.getRef() + ", event value type=" + eventValue.getClass() + ", attribute value type=" + attributeValueType;
- return new AssetProcessingException(INVALID_VALUE, msg);
- });
- }).orElse(null);
- event.setValue(value);
+ // Type coercion
+ Object value = event.getValue().map(eventValue -> {
+ Class<?> attributeValueType = attribute.getTypeClass();
+ return ValueUtil.getValueCoerced(eventValue, attributeValueType).orElseThrow(() -> {
+ String msg = "Event processing failed unable to coerce value into the correct value type: realm=" + event.getRealm() + ", attribute=" + event.getRef() + ", event value type=" + eventValue.getClass() + ", attribute value type=" + attributeValueType;
+ return new AssetProcessingException(INVALID_VALUE, msg);
+ });
+ }).orElse(null);
+ event.setValue(value);
- AttributeEvent enrichedEvent = new AttributeEvent(asset, attribute, event.getSource(), event.getValue().orElse(null), event.getTimestamp(), attribute.getValue().orElse(null), attribute.getTimestamp().orElse(0L));
+ AttributeEvent enrichedEvent = new AttributeEvent(asset, attribute, event.getSource(), event.getValue().orElse(null), event.getTimestamp(), attribute.getValue().orElse(null), attribute.getTimestamp().orElse(0L));
- // Do standard JSR-380 validation on the event
- Set<ConstraintViolation<AttributeEvent>> validationFailures = ValueUtil.validate(enrichedEvent);
+ // Do standard JSR-380 validation on the event
+ Set<ConstraintViolation<AttributeEvent>> validationFailures = ValueUtil.validate(enrichedEvent);
- if (!validationFailures.isEmpty()) {
- String msg = "Event processing failed value failed constraint validation: realm=" + enrichedEvent.getRealm() + ", attribute=" + enrichedEvent.getRef() + ", event value type=" + enrichedEvent.getValue().map(v -> v.getClass().getName()).orElse("null") + ", attribute value type=" + enrichedEvent.getTypeClass();
- throw new AssetProcessingException(INVALID_VALUE, msg);
- }
+ if (!validationFailures.isEmpty()) {
+ String msg = "Event processing failed value failed constraint validation: realm=" + enrichedEvent.getRealm() + ", attribute=" + enrichedEvent.getRef() + ", event value type=" + enrichedEvent.getValue().map(v -> v.getClass().getName()).orElse("null") + ", attribute value type=" + enrichedEvent.getTypeClass();
+ throw new AssetProcessingException(INVALID_VALUE, msg);
+ }
- // TODO: Remove AttributeExecuteStatus
+ // TODO: Remove AttributeExecuteStatus
// // For executable attributes, non-sensor sources can set a writable attribute execute status
// if (attribute.getType() == ValueType.EXECUTION_STATUS && source != SENSOR) {
// Optional<AttributeExecuteStatus> status = event.getValue()
@@ -407,51 +390,48 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
// }
// }
- String interceptorName = null;
- boolean intercepted = false;
-
- for (AttributeEventInterceptor interceptor : eventInterceptors) {
- try {
- intercepted = interceptor.intercept(em, enrichedEvent);
- } catch (AssetProcessingException ex) {
- throw new AssetProcessingException(ex.getReason(), "Interceptor '" + interceptor + "' error=" + ex.getMessage());
- } catch (Throwable t) {
- throw new AssetProcessingException(
- INTERCEPTOR_FAILURE,
- "Interceptor '" + interceptor + "' uncaught exception error=" + t.getMessage(),
- t
- );
+ String interceptorName = null;
+ boolean intercepted = false;
+
+ for (AttributeEventInterceptor interceptor : eventInterceptors) {
+ try {
+ intercepted = interceptor.intercept(em, enrichedEvent);
+ } catch (AssetProcessingException ex) {
+ throw new AssetProcessingException(ex.getReason(), "Interceptor '" + interceptor + "' error=" + ex.getMessage());
+ } catch (Throwable t) {
+ throw new AssetProcessingException(
+ INTERCEPTOR_FAILURE,
+ "Interceptor '" + interceptor + "' uncaught exception error=" + t.getMessage(),
+ t
+ );
+ }
+ if (intercepted) {
+ interceptorName = interceptor.getName();
+ break;
+ }
}
+
if (intercepted) {
- interceptorName = interceptor.getName();
- break;
+ LOG.log(System.Logger.Level.TRACE, "Event intercepted: interceptor=" + interceptorName + ", ref=" + enrichedEvent.getRef() + ", source=" + enrichedEvent.getSource());
+ } else {
+ if (enrichedEvent.isOutdated()) {
+ LOG.log(System.Logger.Level.INFO, () -> "Event is older than current attribute value so marking as outdated: ref=" + enrichedEvent.getRef() + ", event=" + Instant.ofEpochMilli(enrichedEvent.getTimestamp()) + ", previous=" + Instant.ofEpochMilli(enrichedEvent.getOldValueTimestamp()));
+ // Generate an event for this so internal subscribers can act on it if needed
+ clientEventService.publishEvent(new OutdatedAttributeEvent(enrichedEvent));
+ } else if (!assetStorageService.updateAttributeValue(em, enrichedEvent)) {
+ throw new AssetProcessingException(
+ STATE_STORAGE_FAILED, "database update failed, no rows updated"
+ );
+ }
}
- }
- if (intercepted) {
- LOG.log(System.Logger.Level.TRACE, "Event intercepted: interceptor=" + interceptorName + ", ref=" + enrichedEvent.getRef() + ", source=" + enrichedEvent.getSource());
- } else {
- if (enrichedEvent.isOutdated()) {
- LOG.log(System.Logger.Level.INFO, () -> "Event is older than current attribute value so marking as outdated: ref=" + enrichedEvent.getRef() + ", event=" + Instant.ofEpochMilli(enrichedEvent.getTimestamp()) + ", previous=" + Instant.ofEpochMilli(enrichedEvent.getOldValueTimestamp()));
- // Generate an event for this so internal subscribers can act on it if needed
- clientEventService.publishEvent(new OutdatedAttributeEvent(enrichedEvent));
- } else if (!assetStorageService.updateAttributeValue(em, enrichedEvent)) {
- throw new AssetProcessingException(
- STATE_STORAGE_FAILED, "database update failed, no rows updated"
- );
+ if (LOG.isLoggable(System.Logger.Level.DEBUG)) {
+ long processingMillis = System.currentTimeMillis() - startMillis;
+ LOG.log(System.Logger.Level.DEBUG, "<<< Attribute event processed in " + processingMillis + "ms: processor=" + Thread.currentThread().getName() + ", event=" + enrichedEvent);
}
- }
-
- long processingMillis = System.currentTimeMillis() - startMillis;
-
- if (processingMillis > 50) {
- LOG.log(System.Logger.Level.INFO, () -> "<<< Attribute event processing took a long time " + processingMillis + "ms: processor=" + Thread.currentThread().getName() + ", event=" + enrichedEvent);
- } else {
- LOG.log(System.Logger.Level.DEBUG, () -> "<<< Attribute event processed in " + processingMillis + "ms: processor=" + Thread.currentThread().getName() + ", event=" + enrichedEvent);
- }
+ return true;
+ });
});
-
- return true;
}
@Override
@@ -459,13 +439,4 @@ public class AssetProcessingService extends RouteBuilder implements ContainerSer
return getClass().getSimpleName() + "{" +
'}';
}
-
- protected int getEventProcessingRouteNumber(String assetId) {
- int charCode = Character.codePointAt(assetId, 0) + Character.codePointAt(assetId, 1);
- return (charCode % eventProcessingThreadCount) + 1;
- }
-
- protected String getEventProcessingRouteURI(int routeNumber) {
- return EVENT_PROCESSOR_URI_PREFIX + routeNumber + EVENT_PROCESSOR_URI_SUFFIX;
- }
}
diff --git a/manager/src/main/java/org/openremote/manager/asset/AssetResourceImpl.java b/manager/src/main/java/org/openremote/manager/asset/AssetResourceImpl.java
index 862f2a315..506f2737c 100644
--- a/manager/src/main/java/org/openremote/manager/asset/AssetResourceImpl.java
+++ b/manager/src/main/java/org/openremote/manager/asset/AssetResourceImpl.java
@@ -53,7 +53,7 @@ import java.util.logging.Logger;
import java.util.stream.IntStream;
import static jakarta.ws.rs.core.Response.Status.*;
-import static org.openremote.manager.asset.AssetProcessingService.ATTRIBUTE_EVENT_ROUTER_QUEUE;
+import static org.openremote.manager.asset.AssetProcessingService.ATTRIBUTE_EVENT_PROCESSOR;
import static org.openremote.model.query.AssetQuery.Access;
import static org.openremote.model.value.MetaItemType.*;
@@ -560,9 +560,10 @@ public class AssetResourceImpl extends ManagerWebResource implements AssetResour
// Process synchronously - need to directly use the ATTRIBUTE_EVENT_QUEUE as the client inbound queue
// has multiple consumers and so doesn't support In/Out MEP
+ event.setSource(AssetResource.class.getSimpleName());
Object result = messageBrokerService.getFluentProducerTemplate()
.withBody(event)
- .to(ATTRIBUTE_EVENT_ROUTER_QUEUE)
+ .to(ATTRIBUTE_EVENT_PROCESSOR)
.request();
if (result instanceof AssetProcessingException processingException) {
diff --git a/manager/src/main/java/org/openremote/manager/asset/AssetStorageService.java b/manager/src/main/java/org/openremote/manager/asset/AssetStorageService.java
index ada04e2c4..c612e2dfb 100644
--- a/manager/src/main/java/org/openremote/manager/asset/AssetStorageService.java
+++ b/manager/src/main/java/org/openremote/manager/asset/AssetStorageService.java
@@ -49,7 +49,8 @@ import org.openremote.model.asset.impl.ThingAsset;
import org.openremote.model.attribute.Attribute;
import org.openremote.model.attribute.AttributeEvent;
import org.openremote.model.attribute.AttributeMap;
-import org.openremote.model.event.shared.EventRequestResponseWrapper;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.EventSubscription;
import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.query.AssetQuery;
@@ -57,6 +58,7 @@ import org.openremote.model.query.LogicGroup;
import org.openremote.model.query.filter.*;
import org.openremote.model.security.ClientRole;
import org.openremote.model.security.User;
+import org.openremote.model.util.LockByKey;
import org.openremote.model.util.Pair;
import org.openremote.model.util.TextUtil;
import org.openremote.model.util.ValueUtil;
@@ -64,22 +66,19 @@ import org.postgresql.util.PGobject;
import java.sql.*;
import java.util.*;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
+import java.util.function.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
-import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.*;
import static java.util.stream.Collectors.groupingBy;
import static org.openremote.container.persistence.PersistenceService.PERSISTENCE_TOPIC;
import static org.openremote.container.persistence.PersistenceService.isPersistenceEventForEntityType;
-import static org.openremote.manager.event.ClientEventService.CLIENT_INBOUND_QUEUE;
import static org.openremote.model.attribute.Attribute.getAddedOrModifiedAttributes;
import static org.openremote.model.query.AssetQuery.*;
import static org.openremote.model.query.AssetQuery.Access.*;
@@ -152,15 +151,14 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
}
AssetFilter<T> filter = (AssetFilter<T>) subscription.getFilter();
+
if (filter == null) {
filter = new AssetFilter<>();
subscription.setFilter(filter);
}
- filter.setInternal(subscription.isInternal());
-
- // Internal subscribers and superusers can get events for any asset in any realm
- if (subscription.isInternal() || (auth != null && auth.isSuperUser())) {
+ // Superusers can get events for any asset in any realm
+ if (auth != null && auth.isSuperUser()) {
return true;
}
@@ -228,6 +226,8 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
protected ManagerIdentityService identityService;
protected ClientEventService clientEventService;
protected GatewayService gatewayService;
+ protected ExecutorService executorService;
+ protected final LockByKey assetLocks = new LockByKey();
/**
* Will evaluate each {@link CalendarEventPredicate} and apply it depending on the {@link LogicGroup} type
@@ -313,6 +313,7 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
identityService = container.getService(ManagerIdentityService.class);
clientEventService = container.getService(ClientEventService.class);
gatewayService = container.getService(GatewayService.class);
+ executorService = container.getExecutor();
EventSubscriptionAuthorizer assetEventAuthorizer = AssetStorageService.assetInfoAuthorizer(identityService, this);
clientEventService.addSubscriptionAuthorizer((realm, auth, subscription) -> {
@@ -341,6 +342,11 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
return authorize && authorizeAssetQuery(((HasAssetQuery)event).getAssetQuery(), auth, realm);
});
+ // TODO: Update once client event service supports interface subscriptions
+ clientEventService.addSubscription(ReadAssetEvent.class, this::onReadRequest);
+ clientEventService.addSubscription(ReadAssetsEvent.class, this::onReadRequest);
+ clientEventService.addSubscription(ReadAttributeEvent.class, this::onReadRequest);
+
container.getService(ManagerWebService.class).addApiSingleton(
new AssetResourceImpl(
container.getService(TimerService.class),
@@ -379,60 +385,6 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
.routeId("Persistence-Asset")
.filter(isPersistenceEventForEntityType(Asset.class))
.process(exchange -> publishModificationEvents(exchange.getIn().getBody(PersistenceEvent.class)));
-
- // React if a client wants to read assets and attributes
- from(CLIENT_INBOUND_QUEUE)
- .routeId("ClientInbound-Query")
- .filter(body().isInstanceOf(HasAssetQuery.class))
- .process(exchange -> {
- HasAssetQuery hasAssetQuery = exchange.getIn().getBody(HasAssetQuery.class);
- AssetQuery assetQuery = hasAssetQuery.getAssetQuery();
- String sessionKey = ClientEventService.getSessionKey(exchange);
- String messageId = exchange.getIn().getHeader(ClientEventService.HEADER_REQUEST_RESPONSE_MESSAGE_ID, String.class);
- Object response = null;
-
- if (hasAssetQuery instanceof ReadAssetsEvent) {
- List<Asset<?>> assets = findAll(assetQuery);
- response = new AssetsEvent(assets);
- } else {
- Asset<?> asset = find(assetQuery);
- String assetId;
- String attributeName = null;
-
- if (asset != null) {
- if (hasAssetQuery instanceof ReadAttributeEvent readAttributeEvent) {
- assetId = readAttributeEvent.getAttributeRef().getId();
- attributeName = readAttributeEvent.getAttributeRef().getName();
- } else {
- assetId = ((ReadAssetEvent) hasAssetQuery).getAssetId();
- }
-
- if (!TextUtil.isNullOrEmpty(attributeName)) {
- Attribute<?> assetAttribute = asset.getAttributes().get(attributeName).orElse(null);
- if (assetAttribute != null) {
- // Check access constraints
- if (assetQuery.access == null
- || assetQuery.access == PRIVATE
- || (assetQuery.access == PUBLIC && assetAttribute.getMetaValue(ACCESS_PUBLIC_READ).orElse(false))
- || (assetQuery.access == PROTECTED && assetAttribute.getMetaValue(ACCESS_RESTRICTED_READ).orElse(false))) {
- response = new AttributeEvent(assetId, attributeName, assetAttribute.getValue().orElse(null), assetAttribute.getTimestamp().orElse(0L));
- }
- }
- } else {
- response = new AssetEvent(AssetEvent.Cause.READ, asset, null);
- }
- }
- }
-
- if (response != null) {
- if (!isNullOrEmpty(messageId)) {
- response = new EventRequestResponseWrapper<>(messageId, (SharedEvent)response);
- }
- clientEventService.sendToSession(sessionKey, response);
- }
-
- })
- .end();
}
/**
@@ -640,15 +592,20 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
LOG.finest("Merging asset: " + asset);
}
- return persistenceService.doReturningTransaction(em -> {
-
- long startTime = System.currentTimeMillis();
+ if (asset.getId() != null || asset.getParentId() != null) {
String gatewayId = gatewayService.getLocallyRegisteredGatewayId(asset.getId(), asset.getParentId());
if (!skipGatewayCheck && gatewayId != null) {
- LOG.fine("Sending asset merge request to gateway: Gateway ID=" + gatewayId);
- return gatewayService.mergeGatewayAsset(gatewayId, asset);
+ String msg = "Cannot directly add or modify a descendant asset on a gateway asset, do this on the gateway itself: Gateway ID=" + gatewayId;
+ LOG.info(msg);
+ throw new IllegalStateException(msg);
}
+ }
+
+ String assetId = asset.getId() != null ? asset.getId() : "";
+ return withAssetLock(assetId, () -> persistenceService.doReturningTransaction(em -> {
+
+ long startTime = System.currentTimeMillis();
// Validate realm
if (asset.getRealm() == null) {
@@ -834,7 +791,7 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
}
return updatedAsset;
- });
+ }));
}
/**
@@ -847,9 +804,17 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
public boolean delete(List<String> assetIds, boolean skipGatewayCheck) {
List<String> ids = new ArrayList<>(assetIds);
- Map<String, List<String>> gatewayIdAssetIdMap = new HashMap<>();
if (!skipGatewayCheck) {
+
+ // Don't allow deletion of gateway descendant assets (they must be deleted on the gateway itself)
+ boolean gatewayDescendant = ids.stream().anyMatch(id -> gatewayService.getLocallyRegisteredGatewayId(id, null) != null);
+ if (gatewayDescendant) {
+ String msg = "Cannot delete one or more requested assets as they are descendants of a gateway asset";
+ LOG.info(msg);
+ throw new IllegalStateException(msg);
+ }
+
List<String> gatewayIds = ids.stream().filter(id -> gatewayService.isLocallyRegisteredGateway(id)).toList();
if (!gatewayIds.isEmpty()) {
@@ -862,76 +827,40 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
return false;
}
} catch (Exception e) {
+ LOG.log(WARNING, "Failed to delete gateway asset: " + gatewayId, e);
return false;
}
}
}
+ }
- ids.removeIf(id -> {
- String gatewayId = gatewayService.getLocallyRegisteredGatewayId(id, null);
- if (gatewayId != null) {
-
- if (gatewayIds.contains(gatewayId)) {
- // Gateway is being deleted so no need to try and delete this descendant asset
- return true;
- }
-
- gatewayIdAssetIdMap.compute(gatewayId, (gId, aIds) -> {
- if (aIds == null) {
- aIds = new ArrayList<>();
- }
- aIds.add(id);
- return aIds;
- });
- return true;
- }
- return false;
- });
+ if (!ids.isEmpty()) {
+ try {
+ // Get locks for each asset ID
+ ids.forEach(assetLocks::lock);
- if (gatewayIdAssetIdMap.isEmpty() && ids.isEmpty()) {
- return true;
- }
+ persistenceService.doTransaction(em -> {
+ List<Asset<?>> assets = em
+ .createQuery("select a from Asset a where not exists(select child.id from Asset child where child.parentId = a.id and not child.id in :ids) and a.id in :ids", Asset.class)
+ .setParameter("ids", ids)
+ .getResultList().stream().map(asset -> (Asset<?>) asset).collect(Collectors.toList());
- // This is not atomic across gateways
- if (!gatewayIdAssetIdMap.isEmpty()) {
- for (Map.Entry<String, List<String>> gatewayIdAssetIds : gatewayIdAssetIdMap.entrySet()) {
- String gatewayId = gatewayIdAssetIds.getKey();
- List<String> gatewayAssetIds = gatewayIdAssetIds.getValue();
- try {
- boolean deleted = gatewayService.deleteGatewayAssets(gatewayId, gatewayAssetIds);
- if (!deleted) {
- return false;
- }
- } catch (Exception e) {
- return false;
+ if (ids.size() != assets.size()) {
+ throw new IllegalArgumentException("Cannot delete one or more requested assets as they either have children or don't exist");
}
- }
- if (ids.isEmpty()) {
- return true;
- }
+ assets.sort(Comparator.comparingInt((Asset<?> asset) -> asset.getPath() == null ? 0 : asset.getPath().length).reversed());
+ assets.forEach(em::remove);
+ em.flush();
+ });
+ } catch (Exception e) {
+ LOG.log(SEVERE, "Failed to delete one or more requested assets: " + Arrays.toString(assetIds.toArray()), e);
+ return false;
+ } finally {
+ // Release all of the locks
+ ids.forEach(assetLocks::unlock);
}
}
-
- try {
- persistenceService.doTransaction(em -> {
- List<Asset<?>> assets = em
- .createQuery("select a from Asset a where not exists(select child.id from Asset child where child.parentId = a.id and not child.id in :ids) and a.id in :ids", Asset.class)
- .setParameter("ids", ids)
- .getResultList().stream().map(asset -> (Asset<?>) asset).collect(Collectors.toList());
-
- if (assetIds.size() != assets.size()) {
- throw new IllegalArgumentException("Cannot delete one or more requested assets as they either have children or don't exist");
- }
-
- assets.sort(Comparator.comparingInt((Asset<?> asset) -> asset.getPath() == null ? 0 : asset.getPath().length).reversed());
- assets.forEach(em::remove);
- em.flush();
- });
- } catch (Exception e) {
- return false;
- }
-
return true;
}
@@ -1202,6 +1131,19 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
});
}
+ public <R> R withAssetLock(String assetId, Supplier<R> action) {
+ try {
+ assetLocks.lock(assetId);
+ return action.get();
+ } finally {
+ assetLocks.unlock(assetId);
+ }
+ }
+
+ public void withAssetLock(String assetId, Runnable action) {
+ withAssetLock(assetId, action);
+ }
+
protected void createUserAssetLinks(EntityManager em, List<UserAssetLink> userAssets) {
em.unwrap(Session.class).doWork(connection -> {
@@ -1327,8 +1269,8 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
return assets.stream().filter(asset -> calendarEventPredicateMatches(timerService::getCurrentTimeMillis, query, asset)).toList();
}
- if (LOG.isLoggable(FINE)) {
- LOG.fine("Asset query took " + (System.currentTimeMillis() - startMillis) + "ms: return count=" + assets.size());
+ if (LOG.isLoggable(FINEST)) {
+ LOG.finest("Asset query took " + (System.currentTimeMillis() - startMillis) + "ms: return count=" + assets.size());
}
return assets;
@@ -2119,4 +2061,54 @@ public class AssetStorageService extends RouteBuilder implements ContainerServic
throw new IllegalArgumentException("Unsupported operator: " + operator);
}
+
+ protected <T extends HasAssetQuery & RespondableEvent> void onReadRequest(T event) {
+ AssetQuery assetQuery = event.getAssetQuery();
+ Event response = null;
+
+ if (event.getResponseConsumer() == null) {
+ LOG.warning("Cannot respond to read request event as response consumer is not set");
+ return;
+ }
+
+ if (event instanceof ReadAssetsEvent) {
+ List<Asset<?>> assets = findAll(assetQuery);
+ response = new AssetsEvent(assets);
+ } else {
+ Asset<?> asset = find(assetQuery);
+ String assetId;
+ String attributeName = null;
+
+ if (asset != null) {
+ if (event instanceof ReadAttributeEvent readAttributeEvent) {
+ assetId = readAttributeEvent.getAttributeRef().getId();
+ attributeName = readAttributeEvent.getAttributeRef().getName();
+ } else {
+ assetId = ((ReadAssetEvent) event).getAssetId();
+ }
+
+ if (!TextUtil.isNullOrEmpty(attributeName)) {
+ Attribute<?> assetAttribute = asset.getAttributes().get(attributeName).orElse(null);
+ if (assetAttribute != null) {
+ // Check access constraints
+ if (assetQuery.access == null
+ || assetQuery.access == PRIVATE
+ || (assetQuery.access == PUBLIC && assetAttribute.getMetaValue(ACCESS_PUBLIC_READ).orElse(false))
+ || (assetQuery.access == PROTECTED && assetAttribute.getMetaValue(ACCESS_RESTRICTED_READ).orElse(false))) {
+ response = new AttributeEvent(assetId, attributeName, assetAttribute.getValue().orElse(null), assetAttribute.getTimestamp().orElse(0L));
+ }
+ }
+ } else {
+ response = new AssetEvent(AssetEvent.Cause.READ, asset, null);
+ }
+ }
+ }
+
+ if (response != null) {
+ if (!isNullOrEmpty(((SharedEvent) event).getMessageID())) {
+ response.setMessageID(((SharedEvent) event).getMessageID());
+ }
+ event.getResponseConsumer().accept(response);
+ }
+ }
}
diff --git a/manager/src/main/java/org/openremote/manager/asset/AttributeLinkingService.java b/manager/src/main/java/org/openremote/manager/asset/AttributeLinkingService.java
index 056d205e8..ea2a24296 100644
--- a/manager/src/main/java/org/openremote/manager/asset/AttributeLinkingService.java
+++ b/manager/src/main/java/org/openremote/manager/asset/AttributeLinkingService.java
@@ -63,7 +63,7 @@ public class AttributeLinkingService implements ContainerService {
agentService = container.getService(AgentService.class);
gatewayService = container.getService(GatewayService.class);
ClientEventService clientEventService = container.getService(ClientEventService.class);
- clientEventService.addInternalSubscription(AttributeEvent.class, null, this::onAttributeEvent);
+ clientEventService.addSubscription(AttributeEvent.class, null, this::onAttributeEvent);
}
@Override
@@ -75,7 +75,7 @@ public class AttributeLinkingService implements ContainerService {
}
public void onAttributeEvent(AttributeEvent event) {
- if (getClass().getName().equals(event.getSource())) {
+ if (getClass().getSimpleName().equals(event.getSource())) {
LOG.finest("Attribute update came from this service so ignoring to avoid infinite loops: ref=" + event.getRef());
return;
}
@@ -88,7 +88,7 @@ public class AttributeLinkingService implements ContainerService {
protected void sendAttributeEvent(AttributeEvent attributeEvent) {
LOG.finest("Sending attribute event for linked attribute: " + attributeEvent);
- assetProcessingService.sendAttributeEvent(attributeEvent, getClass().getName());
+ assetProcessingService.sendAttributeEvent(attributeEvent, getClass().getSimpleName());
}
protected void processLinkedAttributeUpdate(AttributeInfo attributeInfo, AttributeLink attributeLink) {
diff --git a/manager/src/main/java/org/openremote/manager/asset/ForecastService.java b/manager/src/main/java/org/openremote/manager/asset/ForecastService.java
index 4d619d324..3a73bca73 100644
--- a/manager/src/main/java/org/openremote/manager/asset/ForecastService.java
+++ b/manager/src/main/java/org/openremote/manager/asset/ForecastService.java
@@ -80,7 +80,7 @@ public class ForecastService extends RouteBuilder implements ContainerService {
protected AssetDatapointService assetDatapointService;
protected PersistenceService persistenceService;
protected AssetPredictedDatapointService assetPredictedDatapointService;
- protected ScheduledExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected ForecastTaskManager forecastTaskManager = new ForecastTaskManager();
@Override
@@ -91,7 +91,7 @@ public class ForecastService extends RouteBuilder implements ContainerService {
assetDatapointService = container.getService(AssetDatapointService.class);
persistenceService = container.getService(PersistenceService.class);
assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class);
- executorService = container.getExecutorService();
+ scheduledExecutorService = container.getScheduledExecutor();
}
@Override
@@ -453,10 +453,10 @@ public class ForecastService extends RouteBuilder implements ContainerService {
if (delay.isPresent()) {
LOG.fine("Scheduling next forecast calculation in '" + delay.get() + " [ms]'.");
- scheduledFuture = executorService.schedule(() -> calculateForecasts(), delay.get(), TimeUnit.MILLISECONDS);
+ scheduledFuture = scheduledExecutorService.schedule(() -> calculateForecasts(), delay.get(), TimeUnit.MILLISECONDS);
} else {
scheduledFuture = null;
- if (forecastAttributes.size() > 0) {
+ if (!forecastAttributes.isEmpty()) {
LOG.fine("Scheduling next forecast calculation in '" + DEFAULT_SCHEDULE_DELAY + " [ms]'.");
scheduleForecastCalculation(now, Optional.of(DEFAULT_SCHEDULE_DELAY));
}
diff --git a/manager/src/main/java/org/openremote/manager/asset/console/ConsoleResourceImpl.java b/manager/src/main/java/org/openremote/manager/asset/console/ConsoleResourceImpl.java
index 7ba15c722..d81e2f185 100644
--- a/manager/src/main/java/org/openremote/manager/asset/console/ConsoleResourceImpl.java
+++ b/manager/src/main/java/org/openremote/manager/asset/console/ConsoleResourceImpl.java
@@ -58,7 +58,7 @@ public class ConsoleResourceImpl extends ManagerWebResource implements ConsoleRe
this.assetStorageService = assetStorageService;
// Subscribe for asset events
- clientEventService.addInternalSubscription(
+ clientEventService.addSubscription(
AssetEvent.class,
null,
this::onAssetChange);
diff --git a/manager/src/main/java/org/openremote/manager/datapoint/AbstractDatapointService.java b/manager/src/main/java/org/openremote/manager/datapoint/AbstractDatapointService.java
index 8331e46cf..32b693185 100644
--- a/manager/src/main/java/org/openremote/manager/datapoint/AbstractDatapointService.java
+++ b/manager/src/main/java/org/openremote/manager/datapoint/AbstractDatapointService.java
@@ -45,7 +45,7 @@ import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.Instant;
import java.time.LocalDateTime;
-import java.time.ZoneOffset;
+import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Date;
@@ -67,7 +67,7 @@ public abstract class AbstractDatapointService<T extends Datapoint> implements C
protected PersistenceService persistenceService;
protected AssetStorageService assetStorageService;
protected TimerService timerService;
- protected ScheduledExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected ScheduledFuture<?> dataPointsPurgeScheduledFuture;
@Override
@@ -80,7 +80,7 @@ public abstract class AbstractDatapointService<T extends Datapoint> implements C
persistenceService = container.getService(PersistenceService.class);
assetStorageService = container.getService(AssetStorageService.class);
timerService = container.getService(TimerService.class);
- executorService = container.getExecutorService();
+ scheduledExecutorService = container.getScheduledExecutor();
}
@Override
@@ -91,13 +91,13 @@ public abstract class AbstractDatapointService<T extends Datapoint> implements C
}
public void upsertValue(String assetId, String attributeName, Object value, LocalDateTime timestamp) throws IllegalStateException {
- upsertValue(assetId, attributeName, value, timestamp.toInstant(ZoneOffset.UTC).toEpochMilli());
+ upsertValue(assetId, attributeName, value, timestamp.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
}
public void upsertValue(String assetId, String attributeName, Object value, long timestamp) throws IllegalStateException {
persistenceService.doTransaction(em ->
em.unwrap(Session.class).doWork(connection -> {
- getLogger().finest("Storing datapoint for: id=" + assetId + ", name=" + attributeName + ", timestamp=" + timestamp + ", value=" + value);
+ getLogger().log(Level.FINEST,() -> "Storing datapoint for: id=" + assetId + ", name=" + attributeName + ", timestamp=" + timestamp + ", value=" + value);
PreparedStatement st;
try {
@@ -288,7 +288,7 @@ public abstract class AbstractDatapointService<T extends Datapoint> implements C
st.setString(1, assetId);
st.setString(2, attributeName);
st.setObject(3, pgJsonValue);
- st.setObject(4, Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.UTC).toLocalDateTime());
+ st.setObject(4, Instant.ofEpochMilli(timestamp).atZone(ZoneId.systemDefault()).toLocalDateTime());
}
protected abstract Class<T> getDatapointClass();
diff --git a/manager/src/main/java/org/openremote/manager/datapoint/AssetDatapointService.java b/manager/src/main/java/org/openremote/manager/datapoint/AssetDatapointService.java
index 8991b865b..bc5f336f9 100644
--- a/manager/src/main/java/org/openremote/manager/datapoint/AssetDatapointService.java
+++ b/manager/src/main/java/org/openremote/manager/datapoint/AssetDatapointService.java
@@ -26,10 +26,7 @@ import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Date;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZoneId;
+import java.time.*;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
@@ -93,7 +90,7 @@ public class AssetDatapointService extends AbstractDatapointService<AssetDatapoi
@Override
public void start(Container container) throws Exception {
if (maxDatapointAgeDays > 0) {
- dataPointsPurgeScheduledFuture = executorService.scheduleAtFixedRate(
+ dataPointsPurgeScheduledFuture = scheduledExecutorService.scheduleAtFixedRate(
this::purgeDataPoints,
getFirstPurgeMillis(timerService.getNow()),
Duration.ofDays(1).toMillis(), TimeUnit.MILLISECONDS
@@ -101,7 +98,7 @@ public class AssetDatapointService extends AbstractDatapointService<AssetDatapoi
}
ClientEventService clientEventService = container.getService(ClientEventService.class);
- clientEventService.addInternalSubscription(AttributeEvent.class, null, this::onAttributeEvent);
+ clientEventService.addSubscription(AttributeEvent.class, null, this::onAttributeEvent);
}
public static boolean attributeIsStoreDatapoint(MetaHolder attributeInfo) {
@@ -111,7 +108,7 @@ public class AssetDatapointService extends AbstractDatapointService<AssetDatapoi
public void onAttributeEvent(AttributeEvent attributeEvent) {
if (attributeIsStoreDatapoint(attributeEvent) && attributeEvent.getValue().isPresent()) { // Don't store datapoints with null value
try {
- upsertValue(attributeEvent.getId(), attributeEvent.getName(), attributeEvent.getValue().orElse(null), LocalDateTime.ofInstant(Instant.ofEpochMilli(attributeEvent.getTimestamp()), ZoneId.systemDefault()));
+ upsertValue(attributeEvent.getId(), attributeEvent.getName(), attributeEvent.getValue().orElse(null), Instant.ofEpochMilli(attributeEvent.getTimestamp()).atZone(ZoneId.systemDefault()).toLocalDateTime());
} catch (Exception e) {
throw new AssetProcessingException(AttributeWriteFailure.STATE_STORAGE_FAILED, "Failed to insert or update asset data point for attribute: " + attributeEvent, e);
}
@@ -236,7 +233,7 @@ public class AssetDatapointService extends AbstractDatapointService<AssetDatapoi
public ScheduledFuture<File> exportDatapoints(AttributeRef[] attributeRefs,
long fromTimestamp,
long toTimestamp) {
- return executorService.schedule(() -> {
+ return scheduledExecutorService.schedule(() -> {
String fileName = UniqueIdentifierGenerator.generateId() + ".csv";
StringBuilder sb = new StringBuilder(String.format("copy (select ad.timestamp, a.name, ad.attribute_name, value from asset_datapoint ad, asset a where ad.entity_id = a.id and ad.timestamp >= to_timestamp(%d) and ad.timestamp <= to_timestamp(%d) and (", fromTimestamp / 1000, toTimestamp / 1000))
.append(Arrays.stream(attributeRefs).map(attributeRef -> String.format("(ad.entity_id = '%s' and ad.attribute_name = '%s')", attributeRef.getId(), attributeRef.getName())).collect(Collectors.joining(" or ")))
diff --git a/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java b/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java
index a5e6385c7..c91515310 100644
--- a/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java
+++ b/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java
@@ -65,7 +65,7 @@ public class AssetPredictedDatapointService extends AbstractDatapointService<Ass
@Override
public void start(Container container) throws Exception {
- dataPointsPurgeScheduledFuture = executorService.scheduleAtFixedRate(
+ dataPointsPurgeScheduledFuture = scheduledExecutorService.scheduleAtFixedRate(
this::purgeDataPoints,
getFirstPurgeMillis(timerService.getNow()),
Duration.ofDays(1).toMillis(), TimeUnit.MILLISECONDS
diff --git a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java
index 985e21994..60e8294d0 100644
--- a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java
+++ b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java
@@ -51,10 +51,7 @@ import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiFunction;
import java.util.function.Function;
@@ -101,7 +98,8 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
protected MessageBrokerService messageBrokerService;
protected ClientEventService clientEventService;
protected GatewayService gatewayService;
- protected ScheduledExecutorService executorService;
+ protected ExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected final Map<String, OptimisationInstance> assetOptimisationInstanceMap = new HashMap<>();
protected List<String> forceChargeAssetIds = new ArrayList<>();
@@ -114,7 +112,8 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
messageBrokerService = container.getService(MessageBrokerService.class);
clientEventService = container.getService(ClientEventService.class);
gatewayService = container.getService(GatewayService.class);
- executorService = container.getExecutorService();
+ executorService = container.getExecutor();
+ scheduledExecutorService = container.getScheduledExecutor();
}
@Override
@@ -137,7 +136,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
energyOptimisationAssets.forEach(this::startOptimisation);
- clientEventService.addInternalSubscription(
+ clientEventService.addSubscription(
AttributeEvent.class,
null,
this::processAttributeEvent);
@@ -332,7 +331,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
throw new IllegalStateException("Optimiser instance not found for asset: " + optimisationAssetId);
}
- return executorService.scheduleAtFixedRate(() -> {
+ return scheduledExecutorService.scheduleAtFixedRate(() -> {
try {
runOptimisation(optimisationAssetId, Instant.ofEpochMilli(timerService.getCurrentTimeMillis()).truncatedTo(ChronoUnit.MINUTES));
} catch (Exception e) {
@@ -683,7 +682,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
if (energySchedule != null) {
LOG.finest(getLogPrefix(optimisationAssetId) + "Applying energy schedule for storage asset: " + storageAsset.getId());
- optimiser.applyEnergySchedule(energyLevelMins, energyLevelMaxs, energyCapacity, energySchedule, LocalDateTime.ofInstant(Instant.ofEpochMilli(timerService.getCurrentTimeMillis()), ZoneId.systemDefault()));
+ optimiser.applyEnergySchedule(energyLevelMins, energyLevelMaxs, energyCapacity, energySchedule, Instant.ofEpochMilli(timerService.getCurrentTimeMillis()).atZone(ZoneId.systemDefault()).toLocalDateTime());
}
double maxEnergyLevelMin = Arrays.stream(energyLevelMins).max().orElse(0);
@@ -796,7 +795,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
AttributeRef ref = new AttributeRef(assetId, attribute.getName());
if (attribute.hasMeta(MetaItemType.HAS_PREDICTED_DATA_POINTS)) {
- LocalDateTime timestamp = LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault());
+ LocalDateTime timestamp = optimisationTime.atZone(ZoneId.systemDefault()).toLocalDateTime();
List<ValueDatapoint<?>> predictedData = assetPredictedDatapointService.queryDatapoints(
ref.getId(),
ref.getName(),
diff --git a/manager/src/main/java/org/openremote/manager/energy/ForecastSolarService.java b/manager/src/main/java/org/openremote/manager/energy/ForecastSolarService.java
index 0e59ef22e..20b24cff0 100644
--- a/manager/src/main/java/org/openremote/manager/energy/ForecastSolarService.java
+++ b/manager/src/main/java/org/openremote/manager/energy/ForecastSolarService.java
@@ -78,7 +78,7 @@ public class ForecastSolarService extends RouteBuilder implements ContainerServi
.append(ISO_LOCAL_TIME)
.toFormatter();
- protected ScheduledExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected AssetStorageService assetStorageService;
protected AssetProcessingService assetProcessingService;
protected AssetPredictedDatapointService assetPredictedDatapointService;
@@ -110,7 +110,7 @@ public class ForecastSolarService extends RouteBuilder implements ContainerServi
gatewayService = container.getService(GatewayService.class);
assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class);
clientEventService = container.getService(ClientEventService.class);
- executorService = container.getExecutorService();
+ scheduledExecutorService = container.getScheduledExecutor();
rulesService = container.getService(RulesService.class);
timerService = container.getService(TimerService.class);
@@ -152,9 +152,9 @@ public class ForecastSolarService extends RouteBuilder implements ContainerServi
}
// Start forecast solar thread
- executorService.scheduleAtFixedRate(this::processSolarData, 1, 1, TimeUnit.MINUTES);
+ scheduledExecutorService.scheduleAtFixedRate(this::processSolarData, 1, 1, TimeUnit.MINUTES);
- clientEventService.addInternalSubscription(
+ clientEventService.addSubscription(
AttributeEvent.class,
new AssetFilter<AttributeEvent>().setAssetClasses(Collections.singletonList(ElectricityProducerSolarAsset.class)),
this::processElectricityProducerSolarAssetAttributeEvent);
@@ -162,13 +162,12 @@ public class ForecastSolarService extends RouteBuilder implements ContainerServi
@Override
public void stop(Container container) throws Exception {
- executorService.shutdown();
}
protected static void initClient() {
synchronized (resteasyClient) {
if (resteasyClient.get() == null) {
- resteasyClient.set(createClient(org.openremote.container.Container.EXECUTOR_SERVICE));
+ resteasyClient.set(createClient(org.openremote.container.Container.EXECUTOR));
}
}
}
diff --git a/manager/src/main/java/org/openremote/manager/energy/ForecastWindService.java b/manager/src/main/java/org/openremote/manager/energy/ForecastWindService.java
index 3f7c54c3e..895f5755f 100644
--- a/manager/src/main/java/org/openremote/manager/energy/ForecastWindService.java
+++ b/manager/src/main/java/org/openremote/manager/energy/ForecastWindService.java
@@ -117,7 +117,7 @@ public class ForecastWindService extends RouteBuilder implements ContainerServic
protected GatewayService gatewayService;
protected AssetPredictedDatapointService assetPredictedDatapointService;
protected ClientEventService clientEventService;
- protected ScheduledExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected RulesService rulesService;
private ResteasyWebTarget weatherForecastWebTarget;
private String openWeatherAppId;
@@ -141,7 +141,7 @@ public class ForecastWindService extends RouteBuilder implements ContainerServic
gatewayService = container.getService(GatewayService.class);
assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class);
clientEventService = container.getService(ClientEventService.class);
- executorService = container.getExecutorService();
+ scheduledExecutorService = container.getScheduledExecutor();
rulesService = container.getService(RulesService.class);
openWeatherAppId = getString(container.getConfig(), OR_OPEN_WEATHER_API_APP_ID, null);
@@ -181,7 +181,7 @@ public class ForecastWindService extends RouteBuilder implements ContainerServic
electricityProducerWindAssets.forEach(this::startCalculation);
- clientEventService.addInternalSubscription(
+ clientEventService.addSubscription(
AttributeEvent.class,
null,
this::processAttributeEvent);
@@ -195,7 +195,7 @@ public class ForecastWindService extends RouteBuilder implements ContainerServic
protected static void initClient() {
synchronized (resteasyClient) {
if (resteasyClient.get() == null) {
- resteasyClient.set(createClient(org.openremote.container.Container.EXECUTOR_SERVICE));
+ resteasyClient.set(createClient(org.openremote.container.Container.SCHEDULED_EXECUTOR));
}
}
}
@@ -258,7 +258,7 @@ public class ForecastWindService extends RouteBuilder implements ContainerServic
protected void startCalculation(ElectricityProducerWindAsset electricityProducerWindAsset) {
LOG.fine("Starting calculation for producer wind asset: " + electricityProducerWindAsset);
- calculationFutures.put(electricityProducerWindAsset.getId(), executorService.scheduleAtFixedRate(() -> {
+ calculationFutures.put(electricityProducerWindAsset.getId(), scheduledExecutorService.scheduleAtFixedRate(() -> {
processWeatherData(electricityProducerWindAsset);
}, 0, 1, TimeUnit.HOURS));
}
@@ -294,7 +294,7 @@ public class ForecastWindService extends RouteBuilder implements ContainerServic
for (WeatherForecastModel weatherForecastModel : weatherForecastResponseModel.getList()) {
double powerForecast = calculatePower(electricityProducerWindAsset, weatherForecastModel);
- LocalDateTime timestamp = LocalDateTime.ofInstant(Instant.ofEpochMilli(weatherForecastModel.getTimestamp()), ZoneId.systemDefault());
+ LocalDateTime timestamp = Instant.ofEpochMilli(weatherForecastModel.getTimestamp()).atZone(ZoneId.systemDefault()).toLocalDateTime();
assetPredictedDatapointService.updateValue(electricityProducerWindAsset.getId(), ElectricityProducerAsset.POWER_FORECAST.getName(), -powerForecast, timestamp);
assetPredictedDatapointService.updateValue(electricityProducerWindAsset.getId(), ElectricityProducerAsset.POWER.getName(), -powerForecast, timestamp);
diff --git a/manager/src/main/java/org/openremote/manager/event/ClientEventService.java b/manager/src/main/java/org/openremote/manager/event/ClientEventService.java
index 8f759fb51..2cbea5f93 100644
--- a/manager/src/main/java/org/openremote/manager/event/ClientEventService.java
+++ b/manager/src/main/java/org/openremote/manager/event/ClientEventService.java
@@ -19,9 +19,6 @@
*/
package org.openremote.manager.event;
-import io.micrometer.core.instrument.Counter;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.Tags;
import io.undertow.websockets.core.WebSocketChannel;
import io.undertow.websockets.spi.WebSocketHttpExchange;
import org.apache.camel.Exchange;
@@ -41,25 +38,26 @@ import org.openremote.manager.web.ManagerWebService;
import org.openremote.model.Constants;
import org.openremote.model.Container;
import org.openremote.model.ContainerService;
+import org.openremote.model.asset.AssetFilter;
import org.openremote.model.attribute.AttributeEvent;
import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
+import org.openremote.model.event.TriggeredEventSubscription;
import org.openremote.model.event.shared.*;
import org.openremote.model.syslog.SyslogEvent;
+import org.openremote.model.util.Pair;
import java.io.IOException;
import java.security.Principal;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.*;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.ExecutorService;
import java.util.function.Consumer;
import static java.lang.System.Logger.Level.*;
-import static org.apache.camel.builder.PredicateBuilder.or;
-import static org.openremote.manager.asset.AssetProcessingService.ATTRIBUTE_EVENT_ROUTER_QUEUE;
+import static org.openremote.manager.asset.AssetProcessingService.ATTRIBUTE_EVENT_PROCESSOR;
import static org.openremote.manager.asset.AssetProcessingService.ATTRIBUTE_EVENT_ROUTE_CONFIG_ID;
-import static org.openremote.manager.system.HealthService.OR_CAMEL_ROUTE_METRIC_PREFIX;
import static org.openremote.model.Constants.*;
/**
@@ -105,45 +103,26 @@ import static org.openremote.model.Constants.*;
* </dl>
*/
public class ClientEventService extends RouteBuilder implements ContainerService {
-
- protected static class SessionInfo {
- String connectionType;
- Runnable closeRunnable;
-
- public SessionInfo(String connectionType, Runnable closeRunnable) {
- this.connectionType = connectionType;
- this.closeRunnable = closeRunnable;
- }
- }
-
public static final int PRIORITY = ManagerWebService.PRIORITY - 200;
- public static final String HEADER_CONNECTION_TYPE = ClientEventService.class.getName() + ".HEADER_CONNECTION_TYPE";
- public static final String HEADER_CONNECTION_TYPE_WEBSOCKET = "websocket";
- public static final String HEADER_CONNECTION_TYPE_MQTT = "mqtt";
- public static final String HEADER_REQUEST_RESPONSE_MESSAGE_ID = ClientEventService.class.getName() + ".HEADER_REQUEST_RESPONSE_MESSAGE_ID";
public static final String WEBSOCKET_URI = "undertow://ws://0.0.0.0/websocket/events?fireWebSocketChannelEvents=true&sendTimeout=15000"; // Host is not used as existing undertow instance is utilised
- public static final String CLIENT_INBOUND_QUEUE = "seda://ClientInboundQueue?multipleConsumers=true&concurrentConsumers=2&waitForTaskToComplete=IfReplyExpected&purgeWhenStopping=true&discardIfNoConsumers=true&size=1000";
- public static final String CLIENT_OUTBOUND_QUEUE = "seda://ClientOutboundQueue?multipleConsumers=true&concurrentConsumers=2&purgeWhenStopping=true&discardIfNoConsumers=true&size=1000";
protected static final System.Logger LOG = System.getLogger(ClientEventService.class.getName());
- protected static final String INTERNAL_SESSION_KEY = "ClientEventServiceInternal";
- protected static final String PUBLISH_QUEUE = "seda://ClientPublishQueue?multipleConsumers=false&purgeWhenStopping=true&discardIfNoConsumers=true&size=1000";
+ protected static final String PUBLISH_QUEUE = "direct://ClientPublishQueue";
final protected Collection<EventSubscriptionAuthorizer> eventSubscriptionAuthorizers = new CopyOnWriteArraySet<>();
final protected Collection<EventAuthorizer> eventAuthorizers = new CopyOnWriteArraySet<>();
- final protected Collection<Consumer<Exchange>> exchangeInterceptors = new CopyOnWriteArraySet<>();
- protected ConcurrentMap<String, SessionInfo> sessionKeyInfoMap = new ConcurrentHashMap<>();
+ final protected Set<Pair<EventSubscription<? extends Event>, Consumer<? extends Event>>> eventSubscriptions = new CopyOnWriteArraySet<>();
+ final protected Map<String, WebSocketChannel> sessionChannels = new ConcurrentHashMap<>();
+ final protected Map<String, Map<String, Consumer<? extends Event>>> websocketSessionSubscriptionConsumers = new HashMap<>();
protected TimerService timerService;
protected ExecutorService executorService;
protected MessageBrokerService messageBrokerService;
protected ManagerIdentityService identityService;
- protected EventSubscriptions eventSubscriptions;
protected GatewayService gatewayService;
- protected Set<EventSubscription<?>> pendingInternalSubscriptions;
protected boolean started;
- protected Counter queueFullCounter;
+ protected Consumer<Exchange> websocketInterceptor;
public static String getSessionKey(Exchange exchange) {
- return exchange.getIn().getHeader(SESSION_KEY, String.class);
+ return exchange.getIn().getHeader(UndertowConstants.CONNECTION_KEY, String.class);
}
public static String getClientId(Exchange exchange) {
@@ -165,16 +144,7 @@ public class ClientEventService extends RouteBuilder implements ContainerService
messageBrokerService = container.getService(MessageBrokerService.class);
identityService = container.getService(ManagerIdentityService.class);
gatewayService = container.getService(GatewayService.class);
- executorService = container.getExecutorService();
- MeterRegistry meterRegistry = container.getMeterRegistry();
-
- if (meterRegistry != null) {
- queueFullCounter = meterRegistry.counter(OR_CAMEL_ROUTE_METRIC_PREFIX + "_failed_queue_full", Tags.empty());
- }
-
- eventSubscriptions = new EventSubscriptions(
- container.getService(TimerService.class)
- );
+ executorService = container.getExecutor();
UndertowComponent undertowWebsocketComponent = new UndertowComponent(messageBrokerService.getContext()) {
@Override
@@ -184,35 +154,22 @@ public class ClientEventService extends RouteBuilder implements ContainerService
};
messageBrokerService.getContext().addComponent("undertow", undertowWebsocketComponent);
-
messageBrokerService.getContext().getTypeConverterRegistry().addTypeConverters(
new EventTypeConverters()
);
messageBrokerService.getContext().addRoutes(this);
-
- // Add pending internal subscriptions
- if (pendingInternalSubscriptions != null && !pendingInternalSubscriptions.isEmpty()) {
- pendingInternalSubscriptions.forEach(subscription ->
- doInternalSubscription(INTERNAL_SESSION_KEY, subscription));
- }
-
- pendingInternalSubscriptions = null;
}
// TODO: Remove prefix and just use event type then use a subscription wrapper to pass subscription ID around
+ @SuppressWarnings({"unchecked", "rawtypes"})
@Override
public void configure() throws Exception {
- // Route for deserializing incoming websocket messages and normalising them for the INBOUND_CLIENT_QUEUE
+ // Route for handling inbound websocket messages
from(WEBSOCKET_URI)
.routeId("ClientInbound-Websocket")
.routeConfigurationId(ATTRIBUTE_EVENT_ROUTE_CONFIG_ID)
- .process(exchange -> {
- String connectionKey = exchange.getIn().getHeader(UndertowConstants.CONNECTION_KEY, String.class);
- exchange.getIn().setHeader(HEADER_CONNECTION_TYPE, HEADER_CONNECTION_TYPE_WEBSOCKET);
- exchange.getIn().setHeader(SESSION_KEY, connectionKey);
- })
.choice()
.when(header(UndertowConstants.EVENT_TYPE))
.process(exchange -> {
@@ -243,65 +200,69 @@ public class ClientEventService extends RouteBuilder implements ContainerService
exchange.getIn().setHeader(Constants.AUTH_CONTEXT, authContext);
exchange.getIn().setHeader(Constants.REALM_PARAM_NAME, realm);
- exchange.getIn().setHeader(SESSION_TERMINATOR, getWebsocketSessionTerminator(webSocketChannel));
exchange.getIn().setHeader(SESSION_OPEN, true);
+ sessionChannels.put(getSessionKey(exchange), webSocketChannel);
LOG.log(DEBUG, "Client connection created: " + webSocketChannel.getSourceAddress());
}
case ONCLOSE -> {
AuthContext authContext = (AuthContext)webSocketChannel.getAttribute(Constants.AUTH_CONTEXT);
String realm = (String)webSocketChannel.getAttribute(Constants.REALM_PARAM_NAME);
+ String sessionKey = getSessionKey(exchange);
exchange.getIn().setHeader(Constants.AUTH_CONTEXT, authContext);
exchange.getIn().setHeader(Constants.REALM_PARAM_NAME, realm);
-
- // Use protocol agnostic session open header
exchange.getIn().setHeader(SESSION_CLOSE, true);
+ sessionChannels.remove(getSessionKey(exchange));
LOG.log(DEBUG, "Client connection closed: " + webSocketChannel.getSourceAddress());
+ LOG.log(TRACE, "Removing subscriptions for session: " + sessionKey);
+ synchronized (websocketSessionSubscriptionConsumers) {
+ websocketSessionSubscriptionConsumers.computeIfPresent(sessionKey, (s, subscriptionConsumers) -> {
+ subscriptionConsumers.forEach((subscriptionKey, consumer) -> removeSubscription(consumer));
+ return null;
+ });
+ }
}
case ONERROR -> {
AuthContext authContext = (AuthContext)webSocketChannel.getAttribute(Constants.AUTH_CONTEXT);
String realm = (String)webSocketChannel.getAttribute(Constants.REALM_PARAM_NAME);
+ String sessionKey = getSessionKey(exchange);
exchange.getIn().setHeader(Constants.AUTH_CONTEXT, authContext);
exchange.getIn().setHeader(Constants.REALM_PARAM_NAME, realm);
-
- // Use protocol agnostic session open header
exchange.getIn().setHeader(SESSION_CLOSE_ERROR, true);
LOG.log(DEBUG, "Client connection error: " + webSocketChannel.getSourceAddress());
try {
webSocketChannel.close();
} catch (Exception ignored) {}
+ sessionChannels.remove(getSessionKey(exchange));
+ LOG.log(TRACE, "Removing subscriptions for session: " + sessionKey);
+ synchronized (websocketSessionSubscriptionConsumers) {
+ websocketSessionSubscriptionConsumers.computeIfPresent(sessionKey, (s, subscriptionConsumers) -> {
+ subscriptionConsumers.forEach((subscriptionKey, consumer) -> removeSubscription(consumer));
+ return null;
+ });
+ }
}
}
+
+ // Pass to gateway
+ if (websocketInterceptor != null) {
+ websocketInterceptor.accept(exchange);
+ }
})
- .to(CLIENT_INBOUND_QUEUE)
.stop()
.endChoice()
.end()
.process(exchange -> {
-
WebSocketChannel webSocketChannel = exchange.getIn().getHeader(UndertowConstants.CHANNEL, WebSocketChannel.class);
- AuthContext authContext = (AuthContext)webSocketChannel.getAttribute(Constants.AUTH_CONTEXT);
- String realm = (String)webSocketChannel.getAttribute(Constants.REALM_PARAM_NAME);
+ AuthContext authContext = (AuthContext) webSocketChannel.getAttribute(Constants.AUTH_CONTEXT);
+ String realm = (String) webSocketChannel.getAttribute(Constants.REALM_PARAM_NAME);
exchange.getIn().setHeader(Constants.AUTH_CONTEXT, authContext);
exchange.getIn().setHeader(Constants.REALM_PARAM_NAME, realm);
// Do basic formatting of exchange
- EventRequestResponseWrapper<?> requestResponse = null;
- if (exchange.getIn().getBody() instanceof EventRequestResponseWrapper) {
- requestResponse = exchange.getIn().getBody(EventRequestResponseWrapper.class);
- } else if (exchange.getIn().getBody() instanceof String && exchange.getIn().getBody(String.class).startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX)) {
- requestResponse = exchange.getIn().getBody(EventRequestResponseWrapper.class);
- }
- if (requestResponse != null) {
- SharedEvent event = requestResponse.getEvent();
- exchange.getIn().setHeader(HEADER_REQUEST_RESPONSE_MESSAGE_ID, requestResponse.getMessageId());
- exchange.getIn().setBody(event);
- }
-
- if (exchange.getIn().getBody() instanceof String) {
- String bodyStr = exchange.getIn().getBody(String.class);
+ if (exchange.getIn().getBody() instanceof String bodyStr) {
if (bodyStr.startsWith(EventSubscription.SUBSCRIBE_MESSAGE_PREFIX)) {
exchange.getIn().setBody(exchange.getIn().getBody(EventSubscription.class));
} else if (bodyStr.startsWith(CancelEventSubscription.MESSAGE_PREFIX)) {
@@ -311,149 +272,139 @@ public class ClientEventService extends RouteBuilder implements ContainerService
}
}
- // Perform authorisation
- if (exchange.getIn().getBody() instanceof SharedEvent) {
- SharedEvent event = exchange.getIn().getBody(SharedEvent.class);
+ if (exchange.getIn().getBody() instanceof RespondableEvent respondableEvent) {
+ // Inject a response consumer
+ respondableEvent.setResponseConsumer(ev -> sendToWebsocketSession(getSessionKey(exchange), ev));
+ }
- if (!authorizeEventWrite(realm, authContext, event)) {
- exchange.setRouteStop(true);
- }
- } else if (exchange.getIn().getBody() instanceof EventSubscription<?>) {
- EventSubscription<?> subscription = exchange.getIn().getBody(EventSubscription.class);
+ // Pass to gateway
+ if (websocketInterceptor != null) {
+ websocketInterceptor.accept(exchange);
+ }
+ })
+ .process(exchange -> {
+ AuthContext authContext = exchange.getIn().getHeader(Constants.AUTH_CONTEXT, AuthContext.class);
+ String realm = exchange.getIn().getHeader(Constants.REALM_PARAM_NAME, String.class);
+
+ if (exchange.getIn().getBody() instanceof EventSubscription<?> subscription) {
String sessionKey = getSessionKey(exchange);
+ LOG.log(TRACE, () -> "Adding subscription for session '" + sessionKey + "': " + subscription);
if (!authorizeEventSubscription(realm, authContext, subscription)) {
- sendToSession(sessionKey, new UnauthorizedEventSubscription<>(subscription));
+ sendToWebsocketSession(sessionKey, new UnauthorizedEventSubscription<>(subscription));
exchange.setRouteStop(true);
+ return;
}
- }
- })
- .to(CLIENT_INBOUND_QUEUE)
- .end();
- from(CLIENT_INBOUND_QUEUE)
- .routeId("ClientInbound-EventProcessor")
- .routeConfigurationId(ATTRIBUTE_EVENT_ROUTE_CONFIG_ID)
- .process(exchange -> {
- // Process session open before passing to any interceptors
- Boolean isSessionOpen = exchange.getIn().getHeader(SESSION_OPEN, Boolean.class);
- if (isSessionOpen != null) {
+ // Force subscription to filter only value changed attribute events
+ if (subscription.getFilter() instanceof AssetFilter assetFilter) {
+ subscription.setFilter(assetFilter.setValueChanged(true));
+ }
+
+ // Notify the client that the subscription has been created
+ subscription.setSubscribed(true);
+ sendToWebsocketSession(sessionKey, subscription);
+
+ synchronized (websocketSessionSubscriptionConsumers) {
+ // Create subscription consumer and track it for future removal requests
+ Consumer<? extends SharedEvent> consumer = ev -> onWebsocketSubscriptionTriggered(sessionKey, subscription, ev);
+ Map<String, Consumer<? extends Event>> subscriptionConsumers = websocketSessionSubscriptionConsumers.computeIfAbsent(sessionKey, (s) -> new HashMap<>());
+ String subscriptionKey = subscription.getEventType() + subscription.getSubscriptionId();
+ subscriptionConsumers.put(subscriptionKey, consumer);
+ addSubscription(subscription, consumer);
+ }
+ exchange.setRouteStop(true);
+ } else if (exchange.getIn().getBody() instanceof CancelEventSubscription cancelEventSubscription) {
String sessionKey = getSessionKey(exchange);
- LOG.log(TRACE, "Adding session: " + sessionKey);
- sessionKeyInfoMap.put(sessionKey, createSessionInfo(sessionKey, exchange));
- }
- passToInterceptors(exchange);
- })
- .choice()
- .when(body().isInstanceOf(AttributeEvent.class))
- .process(exchange -> {
- AttributeEvent attributeEvent = exchange.getIn().getBody(AttributeEvent.class);
- // Set timestamp as early as possible if not set
- if (attributeEvent.getTimestamp() <= 0) {
- attributeEvent.setTimestamp(timerService.getCurrentTimeMillis());
+ LOG.log(TRACE, () -> "Cancelling subscription for session '" + sessionKey + "': " + cancelEventSubscription);
+
+ synchronized (websocketSessionSubscriptionConsumers) {
+ websocketSessionSubscriptionConsumers.computeIfPresent(sessionKey, (s, subscriptionConsumers) -> {
+ String subscriptionKey = cancelEventSubscription.getEventType() + cancelEventSubscription.getSubscriptionId();
+ Consumer<? extends Event> consumer = subscriptionConsumers.remove(subscriptionKey);
+ if (consumer != null) {
+ removeSubscription(consumer);
+ }
+ if (subscriptionConsumers.isEmpty()) {
+ return null;
+ }
+ return subscriptionConsumers;
+ });
+ }
+ exchange.setRouteStop(true);
+ } else if (exchange.getIn().getBody() instanceof SharedEvent event) {
+ if (!authorizeEventWrite(realm, authContext, event)) {
+ exchange.setRouteStop(true);
+ return;
+ }
+
+ // Special handling for incoming attribute events
+ if (event instanceof AttributeEvent attributeEvent) {
+ // Set timestamp as early as possible if not set
+ if (attributeEvent.getTimestamp() <= 0) {
+ attributeEvent.setTimestamp(timerService.getCurrentTimeMillis());
+ }
+ attributeEvent.setSource("WebsocketClient");
+
+ messageBrokerService.getFluentProducerTemplate()
+ .withBody(attributeEvent)
+ .to(ATTRIBUTE_EVENT_PROCESSOR)
+ .asyncSend();
+ exchange.setRouteStop(true);
+ return;
+ }
}
})
- .to(ATTRIBUTE_EVENT_ROUTER_QUEUE)
- .stop()
- .when(or(
- header(SESSION_CLOSE),
- header(SESSION_CLOSE_ERROR)
- ))
- .process(exchange -> {
- String sessionKey = getSessionKey(exchange);
- LOG.log(TRACE, "Removing session: " + sessionKey);
- sessionKeyInfoMap.remove(sessionKey);
- eventSubscriptions.cancelAll(sessionKey);
- })
- .stop()
- .end()
- .choice()
- .when(body().isInstanceOf(EventSubscription.class))
- .process(exchange -> {
- String sessionKey = getSessionKey(exchange);
- EventSubscription<?> subscription = exchange.getIn().getBody(EventSubscription.class);
- LOG.log(TRACE, () -> "Adding subscription for session '" + sessionKey + "': " + subscription);
- subscription.setSubscribed(true);
- sendToSession(sessionKey, subscription);
- eventSubscriptions.createOrUpdate(sessionKey, subscription);
- })
- .stop()
- .when(body().isInstanceOf(CancelEventSubscription.class))
- .process(exchange -> {
- String sessionKey = getSessionKey(exchange);
- CancelEventSubscription cancelEventSubscription = exchange.getIn().getBody(CancelEventSubscription.class);
- eventSubscriptions.cancel(sessionKey, cancelEventSubscription);
- LOG.log(TRACE, () -> "Cancelling subscription for session '" + sessionKey + "': " + cancelEventSubscription);
- })
- .stop()
+ .to(PUBLISH_QUEUE)
.end();
- // Split publish messages for individual subscribers
+ // Send event to each interested subscribers
from(PUBLISH_QUEUE)
- .routeId("ClientOutbound-Splitter")
- .routeConfigurationId(ATTRIBUTE_EVENT_ROUTE_CONFIG_ID)
- .split(method(eventSubscriptions, "splitForSubscribers"))
- .process(exchange -> {
- String sessionKey = getSessionKey(exchange);
- SessionInfo sessionInfo = sessionKeyInfoMap.get(sessionKey);
- if (sessionInfo == null) {
- LOG.log(INFO, "Cannot send to requested session it doesn't exist or is disconnected: " + sessionKey);
- return;
- }
- exchange.getIn().setHeader(HEADER_CONNECTION_TYPE, sessionInfo.connectionType);
- })
- .to(CLIENT_OUTBOUND_QUEUE);
-
- // Route messages destined for websocket clients
- from(CLIENT_OUTBOUND_QUEUE)
- .routeId("ClientOutbound-Websocket")
+ .routeId("ClientPublishToSubscribers")
.routeConfigurationId(ATTRIBUTE_EVENT_ROUTE_CONFIG_ID)
- .filter(header(HEADER_CONNECTION_TYPE).isEqualTo(HEADER_CONNECTION_TYPE_WEBSOCKET))
+ .threads().executorService(executorService)
+ .filter(body().isInstanceOf(SharedEvent.class))
.process(exchange -> {
- String sessionKey = exchange.getIn().getHeader(SESSION_KEY, String.class);
- messageBrokerService.getFluentProducerTemplate()
- .withBody(exchange.getIn().getBody())
- .withHeader(UndertowConstants.CONNECTION_KEY, sessionKey)
- .to(WEBSOCKET_URI)
- .asyncSend();
+ SharedEvent event = exchange.getIn().getBody(SharedEvent.class);
+ sendToSubscribers(event);
});
}
- /**
- * Make an internal subscription to {@link SharedEvent}s sent on the client event bus
- */
- public <T extends SharedEvent> String addInternalSubscription(Class<T> eventClass, EventFilter<T> filter, Consumer<T> eventConsumer) throws IllegalStateException {
- return addInternalSubscription(Integer.toString(Objects.hash(eventClass, filter, eventConsumer)), eventClass, filter, eventConsumer);
- }
- public <T extends SharedEvent> String addInternalSubscription(String subscriptionId, Class<T> eventClass, EventFilter<T> filter, Consumer<T> eventConsumer) throws IllegalStateException {
+ @SuppressWarnings("unchecked")
+ protected <T extends SharedEvent> void sendToSubscribers(T event) {
+ eventSubscriptions.forEach(eventSubscriptionConsumerPair -> {
+ EventSubscription<?> subscription = eventSubscriptionConsumerPair.getKey();
- EventSubscription<T> subscription = new EventSubscription<T>(eventClass, filter, subscriptionId, eventConsumer);
- if (eventSubscriptions == null) {
- // Not initialised yet
- if (pendingInternalSubscriptions == null) {
- pendingInternalSubscriptions = new HashSet<>();
+ if (!subscription.getEventType().equals(event.getEventType())) {
+ return;
}
- pendingInternalSubscriptions.add(subscription);
- } else {
- doInternalSubscription(INTERNAL_SESSION_KEY, subscription);
- }
- return subscriptionId;
- }
- protected void doInternalSubscription(String sessionKey, EventSubscription<?> eventSubscription) throws IllegalStateException {
- if (!authorizeEventSubscription(null, null, eventSubscription)) {
- LOG.log(WARNING, () -> "Internal subscription failed: " + eventSubscription);
- throw new IllegalStateException("Internal subscription failed");
- }
- eventSubscriptions.createOrUpdate(sessionKey, eventSubscription);
+ T filteredEvent = subscription.getFilter() == null ? event : ((EventSubscription<T>) subscription).getFilter().apply(event);
+
+ if (filteredEvent == null) {
+ return;
+ }
+
+ Consumer<T> consumer = (Consumer<T>)eventSubscriptionConsumerPair.getValue();
+ consumer.accept(filteredEvent);
+ });
}
- public void cancelInternalSubscription(String sessionId) {
- eventSubscriptions.cancel(INTERNAL_SESSION_KEY, new CancelEventSubscription(sessionId));
+ /**
+ * Authorisation must be done before adding the subscription and is the responsibility of subscription creators.
+ */
+ public void addSubscription(EventSubscription<? extends Event> eventSubscription, Consumer<? extends Event> consumer) throws IllegalStateException {
+ eventSubscriptions.add(new Pair<>(eventSubscription, consumer));
+ }
+ public <T extends Event> void addSubscription(Class<T> eventClass, Consumer<T> consumer) throws IllegalStateException {
+ addSubscription(new EventSubscription<>(eventClass, null), consumer);
+ }
+ public <T extends Event> void addSubscription(Class<T> eventClass, EventFilter<T> filter, Consumer<T> consumer) throws IllegalStateException {
+ addSubscription(new EventSubscription<>(eventClass, filter), consumer);
}
- public void cancelSubscriptions(String sessionId) {
- eventSubscriptions.cancelAll(sessionId);
+ public void removeSubscription(Consumer<? extends Event> consumer) {
+ eventSubscriptions.removeIf(subscriptionConsumerPair -> subscriptionConsumerPair.value == consumer);
}
@Override
@@ -466,14 +417,6 @@ public class ClientEventService extends RouteBuilder implements ContainerService
started = false;
}
- public void addExchangeInterceptor(Consumer<Exchange> exchangeInterceptor) throws RuntimeException {
- exchangeInterceptors.add(exchangeInterceptor);
- }
-
- public void removeExchangeInterceptor(Consumer<Exchange> exchangeInterceptor) {
- exchangeInterceptors.remove(exchangeInterceptor);
- }
-
public void addSubscriptionAuthorizer(EventSubscriptionAuthorizer authorizer) {
this.eventSubscriptionAuthorizers.add(authorizer);
}
@@ -486,7 +429,7 @@ public class ClientEventService extends RouteBuilder implements ContainerService
* This handles basic authorisation checks for clients that want to subscribe to events in the system
*/
public boolean authorizeEventSubscription(String realm, AuthContext authContext, EventSubscription<?> subscription) {
- boolean authorized = subscription.isInternal() || eventSubscriptionAuthorizers.stream()
+ boolean authorized = eventSubscriptionAuthorizers.stream()
.anyMatch(authorizer -> authorizer.authorise(realm, authContext, subscription));
if (!authorized) {
@@ -521,7 +464,7 @@ public class ClientEventService extends RouteBuilder implements ContainerService
}
/**
- * Publish an event to interested clients
+ * Publish an event to interested subscribers
*/
public <T extends Event> void publishEvent(T event) {
// Only publish if service is started
@@ -529,57 +472,50 @@ public class ClientEventService extends RouteBuilder implements ContainerService
return;
}
- if (messageBrokerService != null && messageBrokerService.getFluentProducerTemplate() != null) {
- // Don't log that we are publishing a syslog event,
- if (!(event instanceof SyslogEvent)) {
- LOG.log(System.Logger.Level.TRACE, () -> "Publishing to clients: " + event);
- }
- messageBrokerService.getFluentProducerTemplate()
- .withBody(event)
- .to(PUBLISH_QUEUE)
- .asyncSend();
+ if (!(event instanceof SyslogEvent)) {
+ LOG.log(System.Logger.Level.TRACE, () -> "Publishing to subscribers: " + event);
}
+
+ messageBrokerService.getFluentProducerTemplate()
+ .withBody(event)
+ .to(PUBLISH_QUEUE)
+ .asyncSend();
}
- public void sendToSession(String sessionKey, Object data) {
- if (messageBrokerService != null && messageBrokerService.getFluentProducerTemplate() != null) {
- LOG.log(TRACE, () -> "Sending to session '" + sessionKey + "': " + data);
- SessionInfo sessionInfo = sessionKeyInfoMap.get(sessionKey);
- if (sessionInfo == null) {
- LOG.log(DEBUG, () -> "Send to session '" + sessionKey + "' failed, it doesn't exist or is disconnected: " + data);
- return;
- }
- messageBrokerService.getFluentProducerTemplate()
- .withBody(data)
- .withHeader(SESSION_KEY, sessionKey)
- .withHeader(HEADER_CONNECTION_TYPE, sessionInfo.connectionType)
- .to(CLIENT_OUTBOUND_QUEUE)
- .asyncSend();
- }
+ public void setWebsocketInterceptor(Consumer<Exchange> consumer) {
+ this.websocketInterceptor = consumer;
}
- public void closeSession(String sessionKey) {
- SessionInfo sessionInfo = sessionKeyInfoMap.get(sessionKey);
+ protected void onWebsocketSubscriptionTriggered(String sessionKey, EventSubscription<?> subscription, SharedEvent event) {
+ // Wrap subscription event in triggered wrapper for client to easily route it
+ TriggeredEventSubscription<?> triggeredEventSubscription = new TriggeredEventSubscription<>(Collections.singletonList(event), subscription.getSubscriptionId());
- if (sessionInfo == null || sessionInfo.closeRunnable == null) {
- return;
- }
+ messageBrokerService.getFluentProducerTemplate()
+ .withBody(triggeredEventSubscription)
+ .withHeader(UndertowConstants.CONNECTION_KEY, sessionKey)
+ .to(WEBSOCKET_URI)
+ .asyncSend();
+ }
- LOG.log(DEBUG, "Closing session: " + sessionKey);
- sessionInfo.closeRunnable.run();
+ public void sendToWebsocketSession(String sessionKey, Object data) {
+ messageBrokerService.getFluentProducerTemplate()
+ .withBody(data)
+ .withHeader(UndertowConstants.CONNECTION_KEY, sessionKey)
+ .to(WEBSOCKET_URI)
+ .asyncSend();
}
- @SuppressWarnings("ResultOfMethodCallIgnored")
- protected void passToInterceptors(Exchange exchange) {
- // Pass to each interceptor and stop if any interceptor marks the exchange as stop routing
- exchangeInterceptors.stream().anyMatch(interceptor -> {
- interceptor.accept(exchange);
- boolean stop = exchange.isRouteStop();
- if (stop) {
- LOG.log(TRACE, "Client event interceptor marked exchange as `stop routing`: " + interceptor);
+ public void closeWebsocketSession(String sessionKey) {
+ WebSocketChannel webSocketChannel = sessionChannels.get(sessionKey);
+ if (webSocketChannel != null) {
+ LOG.log(INFO, () -> "Force closing websocket session: " + sessionKey);
+ try {
+ webSocketChannel.close();
+ } catch (IOException e) {
+ LOG.log(INFO, () -> "Failed to close websocket session: " + sessionKey);
+ throw new RuntimeException(e);
}
- return stop;
- });
+ }
}
@Override
@@ -587,21 +523,4 @@ public class ClientEventService extends RouteBuilder implements ContainerService
return getClass().getSimpleName() + "{" +
'}';
}
-
- protected static SessionInfo createSessionInfo(String sessionKey, Exchange exchange) {
- String connectionType = (String) exchange.getIn().getHeader(HEADER_CONNECTION_TYPE);
- Runnable closeRunnable = exchange.getIn().getHeader(SESSION_TERMINATOR, Runnable.class);
- return new SessionInfo(connectionType, closeRunnable);
- }
-
- /**
- * Provides a protocol agnostic way to close a client session
- */
- protected Runnable getWebsocketSessionTerminator(WebSocketChannel webSocketChannel) {
- return () -> {
- try {
- webSocketChannel.close();
- } catch (IOException ignored) {}
- };
- }
}
diff --git a/manager/src/main/java/org/openremote/manager/event/EventSubscriptions.java b/manager/src/main/java/org/openremote/manager/event/EventSubscriptions.java
deleted file mode 100644
index 15da42795..000000000
--- a/manager/src/main/java/org/openremote/manager/event/EventSubscriptions.java
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Copyright 2017, OpenRemote Inc.
- *
- * See the CONTRIBUTORS.txt file in the distribution for a
- * full listing of individual contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package org.openremote.manager.event;
-
-import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
-import org.apache.camel.Exchange;
-import org.apache.camel.Message;
-import org.apache.camel.support.DefaultMessage;
-import org.openremote.container.timer.TimerService;
-import org.openremote.model.event.TriggeredEventSubscription;
-import org.openremote.model.event.shared.CancelEventSubscription;
-import org.openremote.model.event.shared.EventSubscription;
-import org.openremote.model.event.shared.SharedEvent;
-import org.openremote.model.util.TextUtil;
-
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static org.openremote.model.Constants.SESSION_KEY;
-
-/**
- * Manages subscriptions to events for WebSocket sessions.
- */
-public class EventSubscriptions {
-
- private static final Logger LOG = Logger.getLogger(EventSubscriptions.class.getName());
-
- final protected TimerService timerService;
- final protected ConcurrentMap<String, SessionSubscriptions> sessionSubscriptionIdMap = new ConcurrentHashMap<>();
-
- class SessionSubscriptions extends ConcurrentHashSet<SessionSubscription<?>> {
- protected void createOrUpdate(EventSubscription<?> eventSubscription) {
-
- if (TextUtil.isNullOrEmpty(eventSubscription.getSubscriptionId())) {
- cancelByType(eventSubscription.getEventType());
- } else {
- cancelById(eventSubscription.getSubscriptionId());
- }
-
- add(new SessionSubscription<>(timerService.getCurrentTimeMillis(), eventSubscription));
- }
-
- protected void cancelByType(String eventType) {
- removeIf(sessionSubscription -> sessionSubscription.subscriptionId == null && sessionSubscription.subscription.getEventType().equals(eventType));
- }
-
- protected void cancelById(String subscriptionId) {
- removeIf(sessionSubscription -> sessionSubscription.subscription.getSubscriptionId().equals(subscriptionId));
- }
- }
-
- static class SessionSubscription<T extends SharedEvent> {
- long timestamp;
- final EventSubscription<T> subscription;
- final String subscriptionId;
-
- public SessionSubscription(long timestamp, EventSubscription<T> subscription) {
- this.timestamp = timestamp;
- this.subscription = subscription;
- this.subscriptionId = subscription.getSubscriptionId();
- }
-
- public boolean matches(SharedEvent event) {
- return subscription.getEventType().equals(event.getEventType());
- }
- }
-
- public EventSubscriptions(TimerService timerService) {
- this.timerService = timerService;
- }
-
- protected void createOrUpdate(String sessionKey, EventSubscription<?> subscription) {
- LOG.finest("Create/update subscription for session '" + sessionKey + "': " + subscription);
- SessionSubscriptions sessionSubscriptions =
- this.sessionSubscriptionIdMap.computeIfAbsent(sessionKey, k -> new SessionSubscriptions());
- sessionSubscriptions.createOrUpdate(subscription);
- }
-
- protected void cancel(String sessionKey, CancelEventSubscription subscription) {
- if (!this.sessionSubscriptionIdMap.containsKey(sessionKey)) {
- return;
- }
- if (subscription.getEventType() == null && subscription.getSubscriptionId() == null) {
- return;
- }
- LOG.finest("Cancel subscription for session '" + sessionKey + "': " + subscription);
- SessionSubscriptions sessionSubscriptions = this.sessionSubscriptionIdMap.get(sessionKey);
-
- if (sessionSubscriptions == null) {
- return;
- }
-
- if (!TextUtil.isNullOrEmpty(subscription.getSubscriptionId())) {
- sessionSubscriptions.cancelById(subscription.getSubscriptionId());
- } else {
- sessionSubscriptions.cancelByType(subscription.getEventType());
- }
- if (sessionSubscriptions.isEmpty()) {
- this.sessionSubscriptionIdMap.remove(sessionKey);
- }
- }
-
- protected void cancelAll(String sessionKey) {
- if (this.sessionSubscriptionIdMap.containsKey(sessionKey)) {
- LOG.finest("Cancelling all subscriptions for session: " + sessionKey);
- this.sessionSubscriptionIdMap.remove(sessionKey);
- }
- }
-
- /**
- * Used in {@link ClientEventService#PUBLISH_QUEUE}
- */
- @SuppressWarnings({"unchecked", "unused"})
- public <T extends SharedEvent> List<Message> splitForSubscribers(Exchange exchange) {
- List<Message> messageList = new ArrayList<>();
- T event = (T)exchange.getIn().getBody(SharedEvent.class);
-
- if (event == null)
- return messageList;
-
- for (Map.Entry<String, SessionSubscriptions> entry : sessionSubscriptionIdMap.entrySet()) {
- String sessionKey = entry.getKey();
- SessionSubscriptions subscriptions = entry.getValue();
-
- for (SessionSubscription<?> sessionSubscription : subscriptions) {
-
- if (!sessionSubscription.matches(event))
- continue;
-
- SessionSubscription<T> sessionSub = (SessionSubscription<T>) sessionSubscription;
- T filteredEvent = sessionSub.subscription.getFilter() == null ? event : sessionSub.subscription.getFilter().apply(event);
-
- if (filteredEvent != null) {
- LOG.finest("Creating message for subscribed session '" + sessionKey + "': " + filteredEvent);
- List<T> events = Collections.singletonList(filteredEvent);
- TriggeredEventSubscription<T> triggeredEventSubscription = new TriggeredEventSubscription<>(events, sessionSub.subscriptionId);
-
- if (sessionSub.subscription.isInternal()) {
- if (triggeredEventSubscription.getEvents() != null) {
- try {
- triggeredEventSubscription.getEvents().forEach(e ->
- sessionSub.subscription.getInternalConsumer().accept(e));
- } catch (Exception e) {
- LOG.log(Level.WARNING, "Internal subscription consumer has thrown an exception: id=" + triggeredEventSubscription.getSubscriptionId(), e);
- }
- }
- } else {
- Message msg = new DefaultMessage(exchange.getContext());
- msg.setBody(triggeredEventSubscription); // Don't copy the event, use same reference
- msg.setHeaders(new HashMap<>(exchange.getIn().getHeaders())); // Copy headers
- msg.setHeader(SESSION_KEY, sessionKey);
- messageList.add(msg);
- }
- }
- }
- }
- return messageList;
- }
-}
diff --git a/manager/src/main/java/org/openremote/manager/event/EventTypeConverters.java b/manager/src/main/java/org/openremote/manager/event/EventTypeConverters.java
index 9955f9372..ba5801d0f 100644
--- a/manager/src/main/java/org/openremote/manager/event/EventTypeConverters.java
+++ b/manager/src/main/java/org/openremote/manager/event/EventTypeConverters.java
@@ -103,17 +103,4 @@ public class EventTypeConverters implements TypeConverters {
public String writeUnauthorizedEventSubscription(UnauthorizedEventSubscription unauthorizedEventSubscription, Exchange exchange) throws Exception {
return UnauthorizedEventSubscription.MESSAGE_PREFIX + ValueUtil.JSON.writeValueAsString(unauthorizedEventSubscription);
}
-
- @Converter
- public EventRequestResponseWrapper readRequestResponse(String string, Exchange exchange) throws Exception {
- if (!string.startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX))
- return null;
- string = string.substring(EventRequestResponseWrapper.MESSAGE_PREFIX.length());
- return ValueUtil.JSON.readValue(string, EventRequestResponseWrapper.class);
- }
-
- @Converter
- public String writeRequestResponse(EventRequestResponseWrapper requestResponseWrapper, Exchange exchange) throws Exception {
- return EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.JSON.writeValueAsString(requestResponseWrapper);
- }
}
diff --git a/manager/src/main/java/org/openremote/manager/gateway/GatewayClientService.java b/manager/src/main/java/org/openremote/manager/gateway/GatewayClientService.java
index f8ec1e62a..1a8251d70 100644
--- a/manager/src/main/java/org/openremote/manager/gateway/GatewayClientService.java
+++ b/manager/src/main/java/org/openremote/manager/gateway/GatewayClientService.java
@@ -22,26 +22,29 @@ package org.openremote.manager.gateway;
import io.netty.channel.ChannelHandler;
import org.apache.camel.builder.RouteBuilder;
import org.apache.http.client.utils.URIBuilder;
-import org.openremote.manager.rules.AssetQueryPredicate;
-import org.openremote.model.Constants;
-import org.openremote.model.Container;
-import org.openremote.model.attribute.AttributeRef;
-import org.openremote.model.auth.OAuthClientCredentialsGrant;
import org.openremote.agent.protocol.io.AbstractNettyIOClient;
-import org.openremote.model.ContainerService;
import org.openremote.container.message.MessageBrokerService;
-import org.openremote.model.PersistenceEvent;
import org.openremote.container.persistence.PersistenceService;
import org.openremote.container.timer.TimerService;
import org.openremote.manager.asset.AssetProcessingService;
import org.openremote.manager.asset.AssetStorageService;
import org.openremote.manager.event.ClientEventService;
+import org.openremote.manager.rules.AssetQueryPredicate;
import org.openremote.manager.security.ManagerIdentityService;
import org.openremote.manager.web.ManagerWebService;
+import org.openremote.model.Constants;
+import org.openremote.model.Container;
+import org.openremote.model.ContainerService;
+import org.openremote.model.PersistenceEvent;
import org.openremote.model.asset.*;
import org.openremote.model.asset.agent.ConnectionStatus;
import org.openremote.model.attribute.AttributeEvent;
-import org.openremote.model.event.shared.*;
+import org.openremote.model.attribute.AttributeRef;
+import org.openremote.model.auth.OAuthClientCredentialsGrant;
+import org.openremote.model.event.shared.EventFilter;
+import org.openremote.model.event.shared.EventSubscription;
+import org.openremote.model.event.shared.RealmFilter;
+import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.gateway.*;
import org.openremote.model.query.AssetQuery;
import org.openremote.model.query.filter.RealmPredicate;
@@ -53,7 +56,7 @@ import org.openremote.model.util.ValueUtil;
import java.io.File;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
@@ -77,16 +80,17 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
protected PersistenceService persistenceService;
protected ClientEventService clientEventService;
protected TimerService timerService;
- protected ScheduledExecutorService executorService;
protected ManagerIdentityService identityService;
protected final Map<String, GatewayConnection> connectionRealmMap = new HashMap<>();
protected final Map<String, GatewayIOClient> clientRealmMap = new HashMap<>();
protected GatewayTunnelFactory gatewayTunnelFactory;
protected Map<String, Map<AttributeRef, Long>> clientAttributeTimestamps = new ConcurrentHashMap<>();
+ protected Consumer<AssetEvent> realmAssetEventConsumer;
+ protected Consumer<AttributeEvent> realmAttributeEventConsumer;
+
@Override
public void init(Container container) throws Exception {
- executorService = container.getExecutorService();
assetStorageService = container.getService(AssetStorageService.class);
assetProcessingService = container.getService(AssetProcessingService.class);
persistenceService = container.getService(PersistenceService.class);
@@ -252,20 +256,22 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
client.addMessageConsumer(message -> onCentralManagerMessage(connection, message));
+ realmAssetEventConsumer = assetEvent ->
+ sendCentralManagerMessage(connection.getLocalRealm(), messageToString(SharedEvent.MESSAGE_PREFIX, assetEvent));
+
// Subscribe to Asset<?> and attribute events of local realm and pass through to connected manager
- clientEventService.addInternalSubscription(
- getClientSessionKey(connection)+"Asset",
+ clientEventService.addSubscription(
AssetEvent.class,
new AssetFilter<AssetEvent>().setRealm(connection.getLocalRealm()),
- assetEvent ->
- sendCentralManagerMessage(connection.getLocalRealm(), messageToString(SharedEvent.MESSAGE_PREFIX, assetEvent)));
+ realmAssetEventConsumer);
- clientEventService.addInternalSubscription(
- getClientSessionKey(connection)+"Attribute",
+ realmAttributeEventConsumer = attributeEvent ->
+ sendCentralManagerMessage(connection.getLocalRealm(), messageToString(SharedEvent.MESSAGE_PREFIX, attributeEvent));
+
+ clientEventService.addSubscription(
AttributeEvent.class,
getOutboundAttribueEventFilter(connection),
- attributeEvent ->
- sendCentralManagerMessage(connection.getLocalRealm(), messageToString(SharedEvent.MESSAGE_PREFIX, attributeEvent)));
+ realmAttributeEventConsumer);
client.connect();
return client;
@@ -301,7 +307,7 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
}
// Allow attribute events that came from the central manager to be returned
- if (getClass().getName().equals(ev.getSource())) {
+ if (getClass().getSimpleName().equals(ev.getSource())) {
return ev;
}
@@ -371,13 +377,14 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
client.disconnect();
client.removeAllConnectionStatusConsumers();
client.removeAllMessageConsumers();
+ client.setEncoderDecoderProvider(null);
} catch (Exception e) {
LOG.log(Level.WARNING, "An exception occurred whilst trying to disconnect the gateway IO client", e);
}
if (connection != null) {
- clientEventService.cancelInternalSubscription(getClientSessionKey(connection)+"Asset");
- clientEventService.cancelInternalSubscription(getClientSessionKey(connection)+"Attribute");
+ clientEventService.removeSubscription(realmAttributeEventConsumer);
+ clientEventService.removeSubscription(realmAssetEventConsumer);
}
}
@@ -387,19 +394,7 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
}
protected void onCentralManagerMessage(GatewayConnection connection, String message) {
- String messageId = null;
- SharedEvent event = null;
-
- if (message.startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX)) {
- EventRequestResponseWrapper<?> wrapper = messageFromString(
- message,
- EventRequestResponseWrapper.MESSAGE_PREFIX,
- EventRequestResponseWrapper.class);
- messageId = wrapper.getMessageId();
- event = wrapper.getEvent();
- } else if (message.startsWith(SharedEvent.MESSAGE_PREFIX)) {
- event = messageFromString(message, SharedEvent.MESSAGE_PREFIX, SharedEvent.class);
- }
+ SharedEvent event = messageFromString(message, SharedEvent.MESSAGE_PREFIX, SharedEvent.class);
if (event != null) {
if (event instanceof GatewayDisconnectEvent) {
@@ -410,15 +405,11 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
}
} else if (event instanceof GatewayCapabilitiesRequestEvent) {
LOG.fine("Central manager requested specifications / capabilities of the gateway.");
+ GatewayCapabilitiesResponseEvent responseEvent = new GatewayCapabilitiesResponseEvent(gatewayTunnelFactory != null);
+ responseEvent.setMessageID(event.getMessageID());
sendCentralManagerMessage(
connection.getLocalRealm(),
- messageToString(
- EventRequestResponseWrapper.MESSAGE_PREFIX,
- new EventRequestResponseWrapper<>(
- messageId,
- new GatewayCapabilitiesResponseEvent(gatewayTunnelFactory != null)
- )
- )
+ messageToString(SharedEvent.MESSAGE_PREFIX, responseEvent)
);
} else if (event instanceof GatewayTunnelStartRequestEvent gatewayTunnelStartRequestEvent) {
LOG.info("Start tunnel request received: " + gatewayTunnelStartRequestEvent);
@@ -429,16 +420,11 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
} catch (Exception e) {
error = e.getMessage();
}
-
+ GatewayTunnelStartResponseEvent responseEvent = new GatewayTunnelStartResponseEvent(error);
+ responseEvent.setMessageID(event.getMessageID());
sendCentralManagerMessage(
connection.getLocalRealm(),
- messageToString(
- EventRequestResponseWrapper.MESSAGE_PREFIX,
- new EventRequestResponseWrapper<>(
- messageId,
- new GatewayTunnelStartResponseEvent(error)
- )
- )
+ messageToString(SharedEvent.MESSAGE_PREFIX, responseEvent)
);
} else if (event instanceof GatewayTunnelStopRequestEvent stopRequestEvent) {
@@ -450,22 +436,16 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
} catch (Exception e) {
error = e.getMessage();
}
-
+ GatewayTunnelStopResponseEvent responseEvent = new GatewayTunnelStopResponseEvent(error);
+ responseEvent.setMessageID(event.getMessageID());
sendCentralManagerMessage(
connection.getLocalRealm(),
- messageToString(
- EventRequestResponseWrapper.MESSAGE_PREFIX,
- new EventRequestResponseWrapper<>(
- messageId,
- new GatewayTunnelStopResponseEvent(error)
- )
- )
+ messageToString(SharedEvent.MESSAGE_PREFIX, responseEvent)
);
} else if (event instanceof AttributeEvent) {
- assetProcessingService.sendAttributeEvent((AttributeEvent)event, getClass().getName());
- } else if (event instanceof AssetEvent) {
- AssetEvent assetEvent = (AssetEvent)event;
+ assetProcessingService.sendAttributeEvent((AttributeEvent)event, getClass().getSimpleName());
+ } else if (event instanceof AssetEvent assetEvent) {
if (assetEvent.getCause() == AssetEvent.Cause.CREATE || assetEvent.getCause() == AssetEvent.Cause.UPDATE) {
Asset asset = assetEvent.getAsset();
asset.setRealm(connection.getLocalRealm());
@@ -476,40 +456,16 @@ public class GatewayClientService extends RouteBuilder implements ContainerServi
LOG.log(Level.INFO, "Request from central manager to create/update an asset failed: Realm=" + connection.getLocalRealm() + ", Asset<?> ID=" + asset.getId(), e);
}
}
- } else if (event instanceof DeleteAssetsRequestEvent) {
- DeleteAssetsRequestEvent deleteRequest = (DeleteAssetsRequestEvent)event;
- LOG.finest("Request from central manager to delete asset(s): Realm=" + connection.getLocalRealm() + ", Asset<?> IDs=" + Arrays.toString(deleteRequest.getAssetIds().toArray()));
- boolean success = false;
- try {
- success = assetStorageService.delete(deleteRequest.getAssetIds());
- } catch (Exception e) {
- LOG.log(Level.INFO, "Request from central manager to create/update an asset failed: Realm=" + connection.getLocalRealm() + ", Asset<?> IDs=" + Arrays.toString(deleteRequest.getAssetIds().toArray()), e);
- } finally {
- sendCentralManagerMessage(
- connection.getLocalRealm(),
- messageToString(
- EventRequestResponseWrapper.MESSAGE_PREFIX,
- new EventRequestResponseWrapper<>(
- messageId,
- new DeleteAssetsResponseEvent(success, deleteRequest.getAssetIds())
- )
- ));
- }
- } else if (event instanceof ReadAssetsEvent) {
- ReadAssetsEvent readAssets = (ReadAssetsEvent)event;
+ } else if (event instanceof ReadAssetsEvent readAssets) {
AssetQuery query = readAssets.getAssetQuery();
// Force realm to be the one that this client is associated with
query.realm(new RealmPredicate(connection.getLocalRealm()));
List<Asset<?>> assets = assetStorageService.findAll(readAssets.getAssetQuery());
-
+ AssetsEvent responseEvent = new AssetsEvent(assets);
+ responseEvent.setMessageID(event.getMessageID());
sendCentralManagerMessage(
connection.getLocalRealm(),
- messageToString(
- EventRequestResponseWrapper.MESSAGE_PREFIX,
- new EventRequestResponseWrapper<>(
- messageId,
- new AssetsEvent(assets)
- )));
+ messageToString(SharedEvent.MESSAGE_PREFIX, responseEvent));
}
}
}
diff --git a/manager/src/main/java/org/openremote/manager/gateway/GatewayConnector.java b/manager/src/main/java/org/openremote/manager/gateway/GatewayConnector.java
index cf4edf355..3b2972976 100644
--- a/manager/src/main/java/org/openremote/manager/gateway/GatewayConnector.java
+++ b/manager/src/main/java/org/openremote/manager/gateway/GatewayConnector.java
@@ -25,18 +25,19 @@ import org.openremote.model.asset.*;
import org.openremote.model.asset.agent.ConnectionStatus;
import org.openremote.model.asset.impl.GatewayAsset;
import org.openremote.model.attribute.AttributeEvent;
-import org.openremote.model.event.shared.EventRequestResponseWrapper;
import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.gateway.*;
import org.openremote.model.query.AssetQuery;
import org.openremote.model.syslog.SyslogCategory;
import org.openremote.model.util.Pair;
-import org.openremote.model.util.UniqueIdentifierGenerator;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.*;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.ToIntFunction;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
@@ -60,11 +61,11 @@ public class GatewayConnector {
protected final String realm;
protected final String gatewayId;
protected final AssetStorageService assetStorageService;
- protected final ScheduledExecutorService executorService;
+ protected final ExecutorService executorService;
+ protected final ScheduledExecutorService scheduledExecutorService;
protected final AssetProcessingService assetProcessingService;
protected final GatewayService gatewayService;
protected final Map<String, Asset<?>> pendingAssetMerges = new HashMap<>();
- protected final AtomicReference<EventRequestResponseWrapper<DeleteAssetsRequestEvent>> pendingAssetDelete = new AtomicReference<>();
protected List<AssetEvent> cachedAssetEvents;
protected List<AttributeEvent> cachedAttributeEvents;
protected Consumer<Object> gatewayMessageConsumer;
@@ -73,12 +74,13 @@ public class GatewayConnector {
protected boolean disabled;
protected boolean initialSyncInProgress;
protected ScheduledFuture<?> syncProcessorFuture;
+ protected Future<?> capabilitiesFuture;
List<String> syncAssetIds;
int syncIndex;
int syncErrors;
String expectedSyncResponseName;
protected boolean tunnellingSupported;
- protected final Map<Class<? extends SharedEvent>, BiConsumer<String, SharedEvent>> eventConsumerMap = new HashMap<>();
+ protected final Map<Class<? extends SharedEvent>, Consumer<SharedEvent>> eventConsumerMap = new HashMap<>();
protected static List<Integer> ALPHA_NUMERIC_CHARACTERS = new ArrayList<>(62);
@@ -97,13 +99,15 @@ public class GatewayConnector {
protected GatewayConnector(
AssetStorageService assetStorageService,
AssetProcessingService assetProcessingService,
- ScheduledExecutorService executorService,
+ ExecutorService executorService,
+ ScheduledExecutorService scheduledExecutorService,
GatewayService gatewayService,
GatewayAsset gateway) {
this.assetStorageService = assetStorageService;
this.assetProcessingService = assetProcessingService;
this.executorService = executorService;
+ this.scheduledExecutorService = scheduledExecutorService;
this.gatewayService = gatewayService;
this.disabled = gateway.getDisabled().orElse(false);
this.realm = gateway.getRealm();
@@ -111,9 +115,8 @@ public class GatewayConnector {
// Setup static inbound event handling
synchronized(eventConsumerMap) {
- eventConsumerMap.put(AssetEvent.class, (msgId, e) -> onAssetEvent((AssetEvent) e));
- eventConsumerMap.put(AttributeEvent.class, (msgId, e) -> onAttributeEvent((AttributeEvent) e));
- eventConsumerMap.put(DeleteAssetsResponseEvent.class, (msgId, e) -> onAssetDeleteResponseEvent(msgId, (DeleteAssetsResponseEvent) e));
+ eventConsumerMap.put(AssetEvent.class, (e) -> onAssetEvent((AssetEvent) e));
+ eventConsumerMap.put(AttributeEvent.class, (e) -> onAttributeEvent((AttributeEvent) e));
}
publishAttributeEvent(new AttributeEvent(gatewayId, GatewayAsset.STATUS, ConnectionStatus.DISCONNECTED));
}
@@ -153,8 +156,7 @@ public class GatewayConnector {
syncIndex = 0;
syncErrors = 0;
- publishAttributeEvent(new AttributeEvent(gatewayId, GatewayAsset.STATUS, ConnectionStatus.CONNECTED));
-
+ publishAttributeEvent(new AttributeEvent(gatewayId, GatewayAsset.STATUS, ConnectionStatus.CONNECTING));
startSync();
}
@@ -174,10 +176,13 @@ public class GatewayConnector {
LOG.finest("Aborting active sync process: " + this);
syncProcessorFuture.cancel(true);
}
+ if (capabilitiesFuture != null) {
+ LOG.finest("Aborting capabilities request: " + this);
+ capabilitiesFuture.cancel(true);
+ }
initialSyncInProgress = false;
pendingAssetMerges.clear();
- pendingAssetDelete.set(null);
publishAttributeEvent(new AttributeEvent(gatewayId, GatewayAsset.STATUS, ConnectionStatus.DISCONNECTED));
}
@@ -210,11 +215,11 @@ public class GatewayConnector {
final AtomicReference<GatewayCapabilitiesResponseEvent> responseRef = new AtomicReference<>();
synchronized (eventConsumerMap) {
- if (eventConsumerMap.containsKey(GatewayCapabilitiesRequestEvent.class)) {
+ if (eventConsumerMap.containsKey(GatewayCapabilitiesResponseEvent.class)) {
return CompletableFuture.failedFuture(new IllegalArgumentException("A capabilities request is already pending"));
}
- eventConsumerMap.put(GatewayCapabilitiesResponseEvent.class, (msgID, e) -> {
+ eventConsumerMap.put(GatewayCapabilitiesResponseEvent.class, (e) -> {
GatewayCapabilitiesResponseEvent response = (GatewayCapabilitiesResponseEvent) e;
synchronized (responseRef) {
@@ -225,10 +230,7 @@ public class GatewayConnector {
}
return CompletableFuture.supplyAsync(() -> {
- sendMessageToGateway(new EventRequestResponseWrapper<>(
- UniqueIdentifierGenerator.generateId(),
- new GatewayCapabilitiesRequestEvent()
- ));
+ sendMessageToGateway(new GatewayCapabilitiesRequestEvent());
// Wait for response indefinitely as timeout handled on CompletableFuture
try {
@@ -268,7 +270,7 @@ public class GatewayConnector {
return CompletableFuture.failedFuture(new IllegalArgumentException("A start tunnel request is already pending"));
}
- eventConsumerMap.put(GatewayTunnelStartResponseEvent.class, (msgID, e) -> {
+ eventConsumerMap.put(GatewayTunnelStartResponseEvent.class, (e) -> {
GatewayTunnelStartResponseEvent response = (GatewayTunnelStartResponseEvent) e;
synchronized (responseRef) {
@@ -279,10 +281,9 @@ public class GatewayConnector {
}
return CompletableFuture.runAsync(() -> {
- sendMessageToGateway(new EventRequestResponseWrapper<>(
- tunnelInfo.getId(),
+ sendMessageToGateway(
new GatewayTunnelStartRequestEvent(gatewayService.getTunnelSSHHostname(), gatewayService.getTunnelSSHPort(), tunnelInfo)
- ));
+ );
// Wait for response indefinitely as timeout handled on CompletableFuture
try {
@@ -321,7 +322,7 @@ public class GatewayConnector {
return CompletableFuture.failedFuture(new IllegalArgumentException("A stop tunnel request is already pending"));
}
- eventConsumerMap.put(GatewayTunnelStopResponseEvent.class, (msgID, e) -> {
+ eventConsumerMap.put(GatewayTunnelStopResponseEvent.class, (e) -> {
GatewayTunnelStopResponseEvent response = (GatewayTunnelStopResponseEvent) e;
synchronized (responseRef) {
@@ -332,10 +333,7 @@ public class GatewayConnector {
}
return CompletableFuture.runAsync(() -> {
- sendMessageToGateway(new EventRequestResponseWrapper<>(
- tunnelInfo.getId(),
- new GatewayTunnelStopRequestEvent(tunnelInfo)
- ));
+ sendMessageToGateway(new GatewayTunnelStopRequestEvent(tunnelInfo));
// Wait for response indefinitely as timeout handled on CompletableFuture
try {
@@ -383,14 +381,14 @@ public class GatewayConnector {
}
protected void publishAttributeEvent(AttributeEvent event) {
- assetProcessingService.sendAttributeEvent(event, GatewayService.class.getName());
+ assetProcessingService.sendAttributeEvent(event, GatewayService.class.getSimpleName());
}
- synchronized protected void onGatewayEvent(String messageId, SharedEvent e) {
+ synchronized protected void onGatewayEvent(SharedEvent e) {
if (initialSyncInProgress) {
if (e instanceof AssetsEvent) {
- onSyncAssetsResponse(messageId, (AssetsEvent) e);
+ onSyncAssetsResponse((AssetsEvent) e);
} else if (e instanceof AttributeEvent) {
cachedAttributeEvents.add((AttributeEvent) e);
} else if (e instanceof AssetEvent) {
@@ -398,9 +396,9 @@ public class GatewayConnector {
}
} else {
synchronized (eventConsumerMap) {
- BiConsumer<String, SharedEvent> consumer = eventConsumerMap.get(e.getClass());
+ Consumer<SharedEvent> consumer = eventConsumerMap.get(e.getClass());
if (consumer != null) {
- consumer.accept(messageId, e);
+ consumer.accept(e);
}
}
}
@@ -416,10 +414,10 @@ public class GatewayConnector {
}
expectedSyncResponseName = ASSET_READ_EVENT_NAME_INITIAL;
- sendMessageToGateway(new EventRequestResponseWrapper<>(
- ASSET_READ_EVENT_NAME_INITIAL,
- new ReadAssetsEvent(new AssetQuery().select(new AssetQuery.Select().excludeAttributes()).recursive(true))));
- syncProcessorFuture = executorService.schedule(this::onSyncAssetsTimeout, RESPONSE_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+ ReadAssetsEvent event = new ReadAssetsEvent(new AssetQuery().select(new AssetQuery.Select().excludeAttributes()).recursive(true));
+ event.setMessageID(expectedSyncResponseName);
+ sendMessageToGateway(event);
+ syncProcessorFuture = scheduledExecutorService.schedule(this::onSyncAssetsTimeout, RESPONSE_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
}
/**
@@ -468,23 +466,22 @@ public class GatewayConnector {
expectedSyncResponseName = ASSET_READ_EVENT_NAME_BATCH + syncIndex;
LOG.fine("Synchronising gateway assets " + syncIndex+1 + "-" + syncIndex + requestAssetIds.length + " of " + syncAssetIds.size() + ": " + this);
- sendMessageToGateway(
- new EventRequestResponseWrapper<>(
- expectedSyncResponseName,
- new ReadAssetsEvent(
- new AssetQuery()
- .ids(requestAssetIds)
- )
- )
+ ReadAssetsEvent event = new ReadAssetsEvent(
+ new AssetQuery()
+ .ids(requestAssetIds)
);
- syncProcessorFuture = executorService.schedule(this::requestAssets, RESPONSE_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+ event.setMessageID(expectedSyncResponseName);
+ sendMessageToGateway(event);
+ syncProcessorFuture = scheduledExecutorService.schedule(this::requestAssets, RESPONSE_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
}
- synchronized protected void onSyncAssetsResponse(String messageId, AssetsEvent e) {
+ synchronized protected void onSyncAssetsResponse(AssetsEvent e) {
if (!isConnected()) {
return;
}
+ String messageId = e.getMessageID();
+
if (!expectedSyncResponseName.equalsIgnoreCase(messageId)) {
LOG.info("Unexpected response from gateway so ignoring (expected=" + expectedSyncResponseName + ", actual =" + messageId + "): " + this);
return;
@@ -647,137 +644,10 @@ public class GatewayConnector {
}
tunnellingSupported = response != null && response.isTunnelingSupported();
publishAttributeEvent(new AttributeEvent(gatewayId, GatewayAsset.TUNNELING_SUPPORTED, tunnellingSupported));
+ publishAttributeEvent(new AttributeEvent(gatewayId, GatewayAsset.STATUS, ConnectionStatus.CONNECTED));
});
}
- @SuppressWarnings("unchecked")
- protected <T extends Asset<?>> T mergeGatewayAsset(T asset, boolean isUpdate) {
-
- if (!isConnected() || isInitialSyncInProgress()) {
- String msg = "Gateway is not connected or initial sync in progress so cannot merge asset: Asset<?> ID=" + asset.getId() + ": " + this;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- }
-
- final String id = asset.getId();
- final String parentId = asset.getParentId();
-
- synchronized (pendingAssetMerges) {
-
- if (id != null && pendingAssetMerges.containsKey(id)) {
- String msg = "Gateway asset merge already pending for this asset: Asset<?> ID=" + id + ": " + this;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- }
-
- if (id == null) {
- // Generate an ID to allow tracking the asset when it is returned from the gateway
- asset.setId(UniqueIdentifierGenerator.generateId());
- } else {
- // Put original gateway asset ID back
- asset.setId(mapAssetId(gatewayId, id, true));
- }
-
- if (gatewayId.equals(parentId)) {
- asset.setParentId(null);
- } else if (parentId != null) {
- // Put original parent asset ID back
- asset.setParentId(mapAssetId(gatewayId, parentId, true));
- }
-
- sendMessageToGateway(new AssetEvent(isUpdate ? AssetEvent.Cause.UPDATE : AssetEvent.Cause.CREATE, asset, null));
- pendingAssetMerges.put(asset.getId(), null);
- }
-
- synchronized (asset.getId()) {
- try {
- asset.getId().wait(RESPONSE_TIMEOUT_MILLIS);
-
- T mergedAsset;
- synchronized (pendingAssetMerges) {
- mergedAsset = (T)pendingAssetMerges.remove(asset.getId());
- }
-
- if (mergedAsset == null) {
- throw new IllegalStateException("Gateway asset merge failed: Asset ID=" + asset.getId() + ", Asset ID Mapped=" + id + ": " + this);
- }
-
- return mergedAsset;
-
- } catch (InterruptedException e) {
- String msg = "Gateway asset merge interrupted: Asset ID=" + asset.getId() + ", Asset ID Mapped=" + id + ": " + this;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- } finally {
- synchronized (pendingAssetMerges) {
- pendingAssetMerges.remove(asset.getId());
- }
- asset.setId(id);
- asset.setParentId(parentId);
- }
- }
- }
-
- protected boolean deleteGatewayAssets(List<String> assetIds) {
-
- if (!isConnected() || isInitialSyncInProgress()) {
- String msg = "Gateway is not connected or initial sync in progress so cannot delete asset(s): Asset<?> IDs=" + Arrays.toString(assetIds.toArray()) + ": " + this;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- }
-
- synchronized (pendingAssetDelete) {
-
- if (pendingAssetDelete.get() != null) {
- String msg = "Gateway asset delete already pending: Asset<?> IDs Mapped=" + Arrays.toString(pendingAssetDelete.get().getEvent().getAssetIds().toArray()) + ": " + this;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- }
-
- List<String> originalIds = assetIds.stream().map(id -> mapAssetId(gatewayId, id, true)).toList();
-
- pendingAssetDelete.set(new EventRequestResponseWrapper<>(
- UniqueIdentifierGenerator.generateId(),
- new DeleteAssetsRequestEvent(new ArrayList<>(originalIds))
- ));
-
- try {
- sendMessageToGateway(pendingAssetDelete.get());
- pendingAssetDelete.wait(RESPONSE_TIMEOUT_MILLIS);
- if (pendingAssetDelete.get() != null) {
- throw new IllegalStateException("Gateway asset delete failed: Asset<?> IDs=" + originalIds + ", Asset<?> IDs Mapped=" + Arrays.toString(assetIds.toArray()) + ": " + this);
- }
- return true;
- } catch (InterruptedException e) {
- String msg = "Gateway asset delete interrupted: Asset<?> IDs=" + originalIds + ", Asset<?> IDs Mapped=" + Arrays.toString(assetIds.toArray()) + ": " + this;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- } finally {
- pendingAssetDelete.set(null);
- }
- }
- }
-
- protected void onAssetDeleteResponseEvent(String messageId, DeleteAssetsResponseEvent e) {
-
- synchronized (pendingAssetDelete) {
- if (pendingAssetDelete.get() == null) {
- return;
- }
-
- if (!pendingAssetDelete.get().getMessageId().equals(messageId)) {
- LOG.info("Gateway asset delete response name does not match request so ignoring: " + this);
- return;
- }
-
- if (e.isDeleted()) {
- pendingAssetDelete.set(null);
- }
-
- pendingAssetDelete.notify();
- }
- }
-
@SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
synchronized protected void onAssetEvent(AssetEvent e) {
diff --git a/manager/src/main/java/org/openremote/manager/gateway/GatewayIOClient.java b/manager/src/main/java/org/openremote/manager/gateway/GatewayIOClient.java
index 4988af321..fbda20837 100644
--- a/manager/src/main/java/org/openremote/manager/gateway/GatewayIOClient.java
+++ b/manager/src/main/java/org/openremote/manager/gateway/GatewayIOClient.java
@@ -22,7 +22,6 @@ package org.openremote.manager.gateway;
import org.openremote.agent.protocol.websocket.WebsocketIOClient;
import org.openremote.model.auth.OAuthGrant;
-import org.openremote.model.event.shared.EventRequestResponseWrapper;
import org.openremote.model.gateway.GatewayCapabilitiesRequestEvent;
import org.openremote.model.syslog.SyslogCategory;
@@ -56,7 +55,12 @@ public class GatewayIOClient extends WebsocketIOClient<String> {
@Override
protected Future<Void> startChannel() {
- CompletableFuture<Void> connectedFuture = toCompletableFuture(super.startChannel());
+ CompletableFuture<Void> connectedFuture;
+ try {
+ connectedFuture = toCompletableFuture(super.startChannel());
+ } catch (Exception e) {
+ connectedFuture = CompletableFuture.failedFuture(e);
+ }
return connectedFuture
.orTimeout(getConnectTimeoutMillis()+1000L, TimeUnit.MILLISECONDS)
@@ -88,7 +92,7 @@ public class GatewayIOClient extends WebsocketIOClient<String> {
@Override
protected void onMessageReceived(String message) {
- if (syncFuture != null && message.startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX) && message.contains(GatewayCapabilitiesRequestEvent.TYPE)) {
+ if (syncFuture != null && message.contains(GatewayCapabilitiesRequestEvent.TYPE)) {
LOG.finest("Gateway connection is now ready");
syncFuture.complete(null);
}
diff --git a/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java b/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java
index e01ac5479..c0d8e73cc 100644
--- a/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java
+++ b/manager/src/main/java/org/openremote/manager/gateway/GatewayService.java
@@ -102,7 +102,8 @@ public class GatewayService extends RouteBuilder implements ContainerService {
protected ClientEventService clientEventService;
protected RulesetStorageService rulesetStorageService;
protected RulesService rulesService;
- protected ScheduledExecutorService executorService;
+ protected ExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected TimerService timerService;
protected String tunnelSSHHostname;
protected String tunnelHostname;
@@ -180,7 +181,8 @@ public class GatewayService extends RouteBuilder implements ContainerService {
assetProcessingService = container.getService(AssetProcessingService.class);
identityService = container.getService(ManagerIdentityService.class);
clientEventService = container.getService(ClientEventService.class);
- executorService = container.getExecutorService();
+ executorService = container.getExecutor();
+ scheduledExecutorService = container.getScheduledExecutor();
rulesetStorageService = container.getService(RulesetStorageService.class);
rulesService = container.getService(RulesService.class);
timerService = container.getService(TimerService.class);
@@ -196,7 +198,7 @@ public class GatewayService extends RouteBuilder implements ContainerService {
active = true;
identityProvider = (ManagerKeycloakIdentityProvider) identityService.getIdentityProvider();
container.getService(MessageBrokerService.class).getContext().addRoutes(this);
- clientEventService.addExchangeInterceptor(this::onMessageIntercept);
+ clientEventService.setWebsocketInterceptor(this::onMessageIntercept);
// Gateways can send AssetsEvents into this central manager so we need to authorize those
clientEventService.addEventAuthorizer((requestRealm, authContext, event) -> {
@@ -263,7 +265,7 @@ public class GatewayService extends RouteBuilder implements ContainerService {
}
// Create connector
- GatewayConnector connector = new GatewayConnector(assetStorageService, assetProcessingService, executorService, this, gateway);
+ GatewayConnector connector = new GatewayConnector(assetStorageService, assetProcessingService, executorService, scheduledExecutorService, this, gateway);
gatewayConnectorMap.put(gateway.getId().toLowerCase(Locale.ROOT), connector);
// Get IDs of all assets under this gateway
@@ -360,15 +362,14 @@ public class GatewayService extends RouteBuilder implements ContainerService {
exchange.setRouteStop(true);
String sessionKey = ClientEventService.getSessionKey(exchange);
String gatewayId = getGatewayIdFromClientId(clientId);
- String messageId = exchange.getIn().getHeader(ClientEventService.HEADER_REQUEST_RESPONSE_MESSAGE_ID, String.class);
- processGatewayMessage(gatewayId, sessionKey, messageId, exchange.getIn().getBody(SharedEvent.class));
+ processGatewayMessage(gatewayId, sessionKey, exchange.getIn().getBody(SharedEvent.class));
}
}
public boolean onAttributeEventIntercepted(EntityManager em, AttributeEvent event) throws AssetProcessingException {
// If the event came from a gateway then we don't want to process it here
- if (getClass().getName().equals(event.getSource())) {
+ if (getClass().getSimpleName().equals(event.getSource())) {
// Clear out agentlink meta so agent interceptor doesn't try intercepting the event
event.getMeta().remove(MetaItemType.AGENT_LINK);
return false;
@@ -462,19 +463,6 @@ public class GatewayService extends RouteBuilder implements ContainerService {
return false;
}
- public <T extends Asset<?>> T mergeGatewayAsset(String gatewayId, T asset) {
- GatewayConnector connector = gatewayConnectorMap.get(gatewayId.toLowerCase(Locale.ROOT));
-
- if (connector == null) {
- String msg = "Gateway not found: Gateway ID=" + gatewayId;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- }
-
- boolean isUpdate = asset.getId() != null && assetIdGatewayIdMap.containsKey(asset.getId());
- return connector.mergeGatewayAsset(asset, isUpdate);
- }
-
public boolean deleteGateway(String gatewayId) {
GatewayConnector connector = gatewayConnectorMap.get(gatewayId.toLowerCase(Locale.ROOT));
@@ -499,22 +487,6 @@ public class GatewayService extends RouteBuilder implements ContainerService {
return assetStorageService.delete(gatewayAssetIds, true);
}
- public boolean deleteGatewayAssets(String gatewayId, List<String> assetIds) {
- if (assetIds == null || assetIds.isEmpty()) {
- return false;
- }
-
- GatewayConnector connector = gatewayConnectorMap.get(gatewayId.toLowerCase(Locale.ROOT));
-
- if (connector == null || !connector.isConnected()) {
- String msg = "Gateway is not connected: Gateway ID=" + gatewayId;
- LOG.info(msg);
- throw new IllegalStateException(msg);
- }
-
- return connector.deleteGatewayAssets(assetIds);
- }
-
public Collection<GatewayTunnelInfo> getTunnelInfos() {
return this.tunnelInfos.values();
}
@@ -676,20 +648,20 @@ public class GatewayService extends RouteBuilder implements ContainerService {
if (connector == null) {
LOG.warning("Gateway connected but not recognised which shouldn't happen: GatewayID=" + gatewayId);
- clientEventService.sendToSession(sessionId, new GatewayDisconnectEvent(GatewayDisconnectEvent.Reason.UNRECOGNISED));
- clientEventService.closeSession(sessionId);
+ clientEventService.sendToWebsocketSession(sessionId, new GatewayDisconnectEvent(GatewayDisconnectEvent.Reason.UNRECOGNISED));
+ clientEventService.closeWebsocketSession(sessionId);
return;
}
if (connector.isDisabled()) {
LOG.warning("Gateway is currently disabled so will be ignored: " + this);
- clientEventService.sendToSession(sessionId, new GatewayDisconnectEvent(GatewayDisconnectEvent.Reason.DISABLED));
- clientEventService.closeSession(sessionId);
+ clientEventService.sendToWebsocketSession(sessionId, new GatewayDisconnectEvent(GatewayDisconnectEvent.Reason.DISABLED));
+ clientEventService.closeWebsocketSession(sessionId);
return;
}
connector.connected(sessionId, createConnectorMessageConsumer(sessionId), () -> {
- clientEventService.closeSession(sessionId);
+ clientEventService.closeWebsocketSession(sessionId);
tunnelInfos.values().removeIf(tunnelInfo -> tunnelInfo.getGatewayId().equals(gatewayId));
});
}
@@ -703,7 +675,7 @@ public class GatewayService extends RouteBuilder implements ContainerService {
}
}
- protected void processGatewayMessage(String gatewayId, String sessionId, String messageId, SharedEvent event) {
+ protected void processGatewayMessage(String gatewayId, String sessionId, SharedEvent event) {
GatewayConnector connector = gatewayConnectorMap.get(gatewayId.toLowerCase(Locale.ROOT));
if (connector == null) {
return;
@@ -712,7 +684,7 @@ public class GatewayService extends RouteBuilder implements ContainerService {
LOG.finest("Gateway event received for an obsolete session so ignoring: " + this);
return;
}
- connector.onGatewayEvent(messageId, event);
+ connector.onGatewayEvent(event);
}
protected void processGatewayChange(GatewayAsset gateway, PersistenceEvent<Asset<?>> persistenceEvent) {
@@ -721,7 +693,7 @@ public class GatewayService extends RouteBuilder implements ContainerService {
case CREATE -> {
createUpdateGatewayServiceUser(gateway);
- GatewayConnector connector = new GatewayConnector(assetStorageService, assetProcessingService, executorService, this, gateway);
+ GatewayConnector connector = new GatewayConnector(assetStorageService, assetProcessingService, executorService, scheduledExecutorService, this, gateway);
gatewayConnectorMap.put(gateway.getId().toLowerCase(Locale.ROOT), connector);
}
case UPDATE -> {
@@ -861,7 +833,7 @@ public class GatewayService extends RouteBuilder implements ContainerService {
}
protected Consumer<Object> createConnectorMessageConsumer(String sessionId) {
- return msg -> clientEventService.sendToSession(sessionId, msg);
+ return msg -> clientEventService.sendToWebsocketSession(sessionId, msg);
}
String getTunnelSSHHostname() {
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/ConnectionMonitorHandler.java b/manager/src/main/java/org/openremote/manager/mqtt/ConnectionMonitorHandler.java
index 81ca09f9f..1998131d6 100644
--- a/manager/src/main/java/org/openremote/manager/mqtt/ConnectionMonitorHandler.java
+++ b/manager/src/main/java/org/openremote/manager/mqtt/ConnectionMonitorHandler.java
@@ -80,7 +80,7 @@ public class ConnectionMonitorHandler extends MQTTHandler {
@Override
public void init(Container container, Configuration serverConfiguration) throws Exception {
super.init(container, serverConfiguration);
- executorService = container.getExecutorService();
+ executorService = container.getExecutor();
mqttBrokerService = container.getService(MQTTBrokerService.class);
assetStorageService = container.getService(AssetStorageService.class);
assetProcessingService = container.getService(AssetProcessingService.class);
@@ -130,7 +130,8 @@ public class ConnectionMonitorHandler extends MQTTHandler {
@Override
public void start(Container container) throws Exception {
- super.start(container);
+ // Don't do super start as don't need to publish or subscribe
+ //super.start(container);
// Don't block start
executorService.submit(() -> {
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/DefaultMQTTHandler.java b/manager/src/main/java/org/openremote/manager/mqtt/DefaultMQTTHandler.java
index 93915a396..38796f16c 100644
--- a/manager/src/main/java/org/openremote/manager/mqtt/DefaultMQTTHandler.java
+++ b/manager/src/main/java/org/openremote/manager/mqtt/DefaultMQTTHandler.java
@@ -23,41 +23,34 @@ import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.mqtt.MqttQoS;
-import org.apache.activemq.artemis.core.config.Configuration;
import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
-import org.apache.camel.builder.RouteBuilder;
import org.keycloak.KeycloakSecurityContext;
import org.openremote.container.security.AuthContext;
import org.openremote.manager.event.ClientEventService;
-import org.openremote.model.Container;
import org.openremote.model.PersistenceEvent;
import org.openremote.model.asset.AssetEvent;
import org.openremote.model.asset.AssetFilter;
import org.openremote.model.asset.UserAssetLink;
import org.openremote.model.attribute.AttributeEvent;
-import org.openremote.model.event.TriggeredEventSubscription;
-import org.openremote.model.event.shared.CancelEventSubscription;
+import org.openremote.model.event.Event;
import org.openremote.model.event.shared.EventSubscription;
-import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.syslog.SyslogCategory;
import org.openremote.model.util.ValueUtil;
import java.nio.charset.StandardCharsets;
import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.function.Function;
+import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
-import static org.apache.camel.support.builder.PredicateBuilder.and;
-import static org.openremote.manager.asset.AssetProcessingService.ATTRIBUTE_EVENT_ROUTE_CONFIG_ID;
-import static org.openremote.manager.event.ClientEventService.*;
+import static org.openremote.manager.asset.AssetProcessingService.ATTRIBUTE_EVENT_PROCESSOR;
+import static org.openremote.manager.mqtt.MQTTBrokerService.connectionToString;
import static org.openremote.manager.mqtt.MQTTBrokerService.getConnectionIDString;
-import static org.openremote.model.Constants.*;
+import static org.openremote.model.Constants.ASSET_ID_REGEXP;
import static org.openremote.model.syslog.SyslogCategory.API;
/**
@@ -66,31 +59,13 @@ import static org.openremote.model.syslog.SyslogCategory.API;
*/
public class DefaultMQTTHandler extends MQTTHandler {
- public static class SubscriberInfo {
- protected Map<String, Consumer<SharedEvent>> topicSubscriptionMap;
-
- public SubscriberInfo(String topic, Consumer<SharedEvent> subscriptionConsumer) {
- this.topicSubscriptionMap = new HashMap<>();
- this.topicSubscriptionMap.put(topic, subscriptionConsumer);
- }
-
- protected void add(String topic, Consumer<SharedEvent> subscriptionConsumer) {
- topicSubscriptionMap.put(topic, subscriptionConsumer);
- }
-
- protected int remove(String topic) {
- topicSubscriptionMap.remove(topic);
- return topicSubscriptionMap.size();
- }
- }
-
public static final int PRIORITY = Integer.MIN_VALUE + 1000;
public static final String ASSET_TOPIC = "asset";
public static final String ATTRIBUTE_TOPIC = "attribute";
public static final String ATTRIBUTE_VALUE_TOPIC = "attributevalue";
public static final String ATTRIBUTE_VALUE_WRITE_TOPIC = "writeattributevalue";
private static final Logger LOG = SyslogCategory.getLogger(API, DefaultMQTTHandler.class);
- protected final ConcurrentMap<String, SubscriberInfo> connectionSubscriberInfoMap = new ConcurrentHashMap<>();
+ final protected Map<String, Map<String, Consumer<? extends Event>>> sessionSubscriptionConsumers = new HashMap<>();
// An authorisation cache for publishing
// TODO: Switch to caffeine library once ActiveMQ has migrated
protected final Cache<String, ConcurrentHashSet<String>> authorizationCache = CacheBuilder.newBuilder()
@@ -104,84 +79,37 @@ public class DefaultMQTTHandler extends MQTTHandler {
return PRIORITY;
}
- @Override
- public void init(Container container, Configuration serverConfiguration) throws Exception {
- super.init(container, serverConfiguration);
- messageBrokerService.getContext().addRoutes(new RouteBuilder() {
- @Override
- public void configure() throws Exception {
-
- // Route messages destined for MQTT clients
- from(CLIENT_OUTBOUND_QUEUE)
- .routeId("ClientOutbound-DefaultMQTTHandler")
- .routeConfigurationId(ATTRIBUTE_EVENT_ROUTE_CONFIG_ID)
- .filter(and(
- header(HEADER_CONNECTION_TYPE).isEqualTo(HEADER_CONNECTION_TYPE_MQTT),
- body().isInstanceOf(TriggeredEventSubscription.class)
- ))
- .process(exchange -> {
- // Get the subscriber consumer
- String connectionID = exchange.getIn().getHeader(SESSION_KEY, String.class);
- SubscriberInfo subscriberInfo = connectionSubscriberInfoMap.get(connectionID);
- if (subscriberInfo != null) {
- TriggeredEventSubscription<?> triggeredEventSubscription = exchange.getIn().getBody(TriggeredEventSubscription.class);
- String topic = triggeredEventSubscription.getSubscriptionId();
- // Should only be a single event in here
- SharedEvent event = triggeredEventSubscription.getEvents().get(0);
- Consumer<SharedEvent> eventConsumer = subscriberInfo.topicSubscriptionMap.get(topic);
- if (eventConsumer != null) {
- eventConsumer.accept(event);
- }
- }
- });
- }
- });
- }
-
@Override
public void onConnect(RemotingConnection connection) {
super.onConnect(connection);
- Map<String, Object> headers = prepareHeaders(null, connection);
- headers.put(SESSION_OPEN, true);
-
- // Put a close connection runnable into the headers for the client event service
- Runnable closeRunnable = () -> {
- if (mqttBrokerService != null) {
- LOG.fine("Calling client session closed force disconnect runnable: " + MQTTBrokerService.connectionToString(connection));
- mqttBrokerService.doForceDisconnect(connection);
- }
- };
- headers.put(SESSION_TERMINATOR, closeRunnable);
- messageBrokerService.getFluentProducerTemplate()
- .withHeaders(headers)
- .to(CLIENT_INBOUND_QUEUE)
- .asyncSend();
}
@Override
public void onDisconnect(RemotingConnection connection) {
super.onDisconnect(connection);
-
- Map<String, Object> headers = prepareHeaders(null, connection);
- headers.put(SESSION_CLOSE, true);
- messageBrokerService.getFluentProducerTemplate()
- .withHeaders(headers)
- .to(CLIENT_INBOUND_QUEUE)
- .asyncSend();
- connectionSubscriberInfoMap.remove(getConnectionIDString(connection));
+ String sessionKey = getSessionKey(connection);
+ LOG.log(Level.FINER, "Removing subscriptions for connection: " + connectionToString(connection));
+ synchronized (sessionSubscriptionConsumers) {
+ sessionSubscriptionConsumers.computeIfPresent(sessionKey, (s, subscriptionConsumers) -> {
+ subscriptionConsumers.forEach((subscriptionKey, consumer) -> clientEventService.removeSubscription(consumer));
+ return null;
+ });
+ }
authorizationCache.invalidate(getConnectionIDString(connection));
}
@Override
public void onConnectionLost(RemotingConnection connection) {
super.onConnectionLost(connection);
- Map<String, Object> headers = prepareHeaders(null, connection);
- headers.put(SESSION_CLOSE_ERROR, true);
- messageBrokerService.getFluentProducerTemplate()
- .withHeaders(headers)
- .to(CLIENT_INBOUND_QUEUE)
- .asyncSend();
- connectionSubscriberInfoMap.remove(getConnectionIDString(connection));
+ String sessionKey = getSessionKey(connection);
+ LOG.log(Level.FINER, "Removing subscriptions for connection: " + connectionToString(connection));
+ synchronized (sessionSubscriptionConsumers) {
+ sessionSubscriptionConsumers.computeIfPresent(sessionKey, (s, subscriptionConsumers) -> {
+ subscriptionConsumers.forEach((subscriptionKey, consumer) -> clientEventService.removeSubscription(consumer));
+ return null;
+ });
+ }
+ authorizationCache.invalidate(getConnectionIDString(connection));
}
@Override
@@ -275,7 +203,7 @@ public class DefaultMQTTHandler extends MQTTHandler {
AssetFilter<?> filter = buildAssetFilter(topic);
if (filter == null) {
- LOG.finest("Failed to process subscription topic: topic=" + topic + ", " + mqttBrokerService.connectionToString(connection));
+ LOG.info("Failed to process subscription topic: topic=" + topic + ", " + mqttBrokerService.connectionToString(connection));
return false;
}
@@ -285,14 +213,12 @@ public class DefaultMQTTHandler extends MQTTHandler {
);
if (!clientEventService.authorizeEventSubscription(topicRealm(topic), authContext, subscription)) {
- LOG.finest("Subscription was not authorised for this user and topic: topic=" + topic + ", subject=" + authContext);
return false;
}
return true;
}
- // TODO: improve authorisation performance
// We make heavy use of authorisation caching as clients can hit this a lot and it is currently quite slow with DB calls
@Override
public boolean canPublish(RemotingConnection connection, KeycloakSecurityContext securityContext, Topic topic) {
@@ -357,61 +283,45 @@ public class DefaultMQTTHandler extends MQTTHandler {
String subscriptionId = topic.getString(); // Use topic as unique subscription ID
AssetFilter filter = buildAssetFilter(topic);
Class subscriptionClass = isAssetTopic ? AssetEvent.class : AttributeEvent.class;
+ String sessionKey = getSessionKey(connection);
if (filter == null) {
- LOG.info("Invalid event filter generated for topic '" + topic + "': " + connection);
+ LOG.info("Invalid event filter generated for topic '" + topic + "': " + connectionToString(connection));
return;
}
- Consumer<SharedEvent> eventConsumer = getSubscriptionEventConsumer(connection, topic);
+ Consumer<Event> consumer = getSubscriptionEventConsumer(connection, topic);
- EventSubscription subscription = new EventSubscription(
+ EventSubscription<Event> subscription = new EventSubscription(
subscriptionClass,
filter,
subscriptionId
);
- Map<String, Object> headers = prepareHeaders(topicRealm(topic), connection);
- messageBrokerService.getFluentProducerTemplate()
- .withHeaders(headers)
- .withBody(subscription)
- .to(CLIENT_INBOUND_QUEUE)
- .asyncSend();
-
- // Track connection subscriptions for restricted user asset link changes (to determine if the client should be disconnected)
- synchronized (connectionSubscriberInfoMap) {
- connectionSubscriberInfoMap.compute(getConnectionIDString(connection), (connectionID, subscriberInfo) -> {
- if (subscriberInfo == null) {
- return new SubscriberInfo(topic.getString(), eventConsumer);
- } else {
- subscriberInfo.add(topic.getString(), eventConsumer);
- return subscriberInfo;
- }
- });
+ synchronized (sessionSubscriptionConsumers) {
+ // Create subscription consumer and track it for future removal requests
+ Map<String, Consumer<? extends Event>> subscriptionConsumers = sessionSubscriptionConsumers.computeIfAbsent(sessionKey, (s) -> new HashMap<>());
+ subscriptionConsumers.put(subscriptionId, consumer);
+ clientEventService.addSubscription(subscription, consumer);
+ LOG.finest(() -> "Client event subscription created for topic '" + topic + "': " + connectionToString(connection));
}
}
- @SuppressWarnings({"unchecked", "rawtypes"})
@Override
public void onUnsubscribe(RemotingConnection connection, Topic topic) {
String subscriptionId = topic.toString();
- boolean isAssetTopic = subscriptionId.startsWith(ASSET_TOPIC);
- Map<String, Object> headers = prepareHeaders(topicRealm(topic), connection);
- Class<SharedEvent> subscriptionClass = (Class) (isAssetTopic ? AssetEvent.class : AttributeEvent.class);
- CancelEventSubscription cancelEventSubscription = new CancelEventSubscription(subscriptionClass, subscriptionId);
- messageBrokerService.getFluentProducerTemplate()
- .withHeaders(headers)
- .withBody(cancelEventSubscription)
- .to(CLIENT_INBOUND_QUEUE)
- .asyncSend();
+ String sessionKey = getSessionKey(connection);
- // Track connection subscriptions for restricted user asset link changes (to determine if the client should be disconnected)
- synchronized (connectionSubscriberInfoMap) {
- connectionSubscriberInfoMap.computeIfPresent(getConnectionIDString(connection), (connectionID, subscriberInfo) -> {
- if (subscriberInfo.remove(topic.getString()) == 0) {
+ synchronized (sessionSubscriptionConsumers) {
+ sessionSubscriptionConsumers.computeIfPresent(sessionKey, (connectionID, subscriptionConsumers) -> {
+ Consumer<? extends Event> consumer = subscriptionConsumers.remove(subscriptionId);
+ if (consumer != null) {
+ clientEventService.removeSubscription(consumer);
+ }
+ if (subscriptionConsumers.isEmpty()) {
return null;
}
- return subscriberInfo;
+ return subscriptionConsumers;
});
}
}
@@ -429,23 +339,32 @@ public class DefaultMQTTHandler extends MQTTHandler {
String payloadContent = body.toString(StandardCharsets.UTF_8);
Object value = ValueUtil.parse(payloadContent).orElse(null);
AttributeEvent attributeEvent = buildAttributeEvent(topicTokens, value);
- Map<String, Object> headers = prepareHeaders(topicRealm(topic), connection);
- LOG.finer("Publishing to client inbound queue: " + attributeEvent);
+
+ // Set timestamp as early as possible if not set
+ if (attributeEvent.getTimestamp() <= 0) {
+ attributeEvent.setTimestamp(timerService.getCurrentTimeMillis());
+ }
+
+ // This is called by a single ActiveMQ client thread (the session) and async offloaded to the container executor,
+ // once the container executor has no free threads the caller will execute (i.e. the client thread) which will
+ // effectively limit rate of publish consumption eventually filling the attribute queue in the broker and
+ // preventing additional attribute events from being added to the queue. This gives us a consistent failure mode
+ // and natural rate limiting.
messageBrokerService.getFluentProducerTemplate()
- .withHeaders(headers)
.withBody(attributeEvent)
- .to(CLIENT_INBOUND_QUEUE)
+ .to(ATTRIBUTE_EVENT_PROCESSOR)
.asyncSend();
}
@Override
public void onUserAssetLinksChanged(RemotingConnection connection, List<PersistenceEvent<UserAssetLink>> changes) {
- if (connectionSubscriberInfoMap.containsKey(getConnectionIDString(connection))) {
+ String sessionKey = getSessionKey(connection);
+ if (sessionSubscriptionConsumers.containsKey(sessionKey)) {
if (changes.stream().allMatch(pe -> pe.getCause() == PersistenceEvent.Cause.CREATE)) {
// Do nothing if only links have been added
return;
}
- LOG.info("User asset links have changed for a connected user with active subscriptions so force disconnecting them: " + mqttBrokerService.connectionToString(connection));
+ LOG.info("User asset links have changed for a connected user with active subscriptions so force disconnecting them: " + connectionToString(connection));
mqttBrokerService.doForceDisconnect(connection);
}
}
@@ -457,7 +376,6 @@ public class DefaultMQTTHandler extends MQTTHandler {
}
protected static AssetFilter<?> buildAssetFilter(Topic topic) {
- boolean isAttributeTopic = isAttributeTopic(topic);
boolean isAssetTopic = isAssetTopic(topic);
String realm = topicRealm(topic);
@@ -523,7 +441,7 @@ public class DefaultMQTTHandler extends MQTTHandler {
}
}
- AssetFilter<?> assetFilter = new AssetFilter<>().setRealm(realm);
+ AssetFilter<?> assetFilter = new AssetFilter<>().setRealm(realm).setValueChanged(true);
if (!assetIds.isEmpty()) {
assetFilter.setAssetIds(assetIds.toArray(new String[0]));
}
@@ -536,10 +454,11 @@ public class DefaultMQTTHandler extends MQTTHandler {
if (!attributeNames.isEmpty()) {
assetFilter.setAttributeNames(attributeNames.toArray(new String[0]));
}
- return assetFilter;
+ // Force subscription to filter only value changed attribute events
+ return assetFilter.setValueChanged(true);
}
- protected Consumer<SharedEvent> getSubscriptionEventConsumer(RemotingConnection connection, Topic topic) {
+ protected <T extends Event> Consumer<T> getSubscriptionEventConsumer(RemotingConnection connection, Topic topic) {
boolean isValueSubscription = ATTRIBUTE_VALUE_TOPIC.equalsIgnoreCase(topicTokenIndexToString(topic, 2));
boolean isAssetTopic = isAssetTopic(topic);
@@ -547,7 +466,7 @@ public class DefaultMQTTHandler extends MQTTHandler {
MqttQoS mqttQoS = MqttQoS.AT_MOST_ONCE;
// Build topic expander (replace wildcards) so it isn't computed for each event
- Function<SharedEvent, String> topicExpander;
+ Function<T, String> topicExpander;
if (isAssetTopic) {
String topicStr = topic.toString();
@@ -603,11 +522,7 @@ public class DefaultMQTTHandler extends MQTTHandler {
return ASSET_TOPIC.equalsIgnoreCase(topicTokenIndexToString(topic, 2));
}
- protected static Map<String, Object> prepareHeaders(String requestRealm, RemotingConnection connection) {
- Map<String, Object> headers = new HashMap<>();
- headers.put(SESSION_KEY, getConnectionIDString(connection));
- headers.put(HEADER_CONNECTION_TYPE, ClientEventService.HEADER_CONNECTION_TYPE_MQTT);
- headers.put(REALM_PARAM_NAME, requestRealm);
- return headers;
+ protected static String getSessionKey(RemotingConnection connection) {
+ return getConnectionIDString(connection);
}
}
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/MQTTBrokerService.java b/manager/src/main/java/org/openremote/manager/mqtt/MQTTBrokerService.java
index cca78e76b..ee25a7c84 100644
--- a/manager/src/main/java/org/openremote/manager/mqtt/MQTTBrokerService.java
+++ b/manager/src/main/java/org/openremote/manager/mqtt/MQTTBrokerService.java
@@ -21,6 +21,7 @@ package org.openremote.manager.mqtt;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
+import io.micrometer.core.instrument.MeterRegistry;
import io.netty.channel.ChannelId;
import org.apache.activemq.artemis.api.core.ActiveMQException;
import org.apache.activemq.artemis.api.core.ActiveMQExceptionType;
@@ -33,6 +34,7 @@ import org.apache.activemq.artemis.api.core.management.CoreNotificationType;
import org.apache.activemq.artemis.api.core.management.ManagementHelper;
import org.apache.activemq.artemis.core.client.impl.ClientSessionInternal;
import org.apache.activemq.artemis.core.config.Configuration;
+import org.apache.activemq.artemis.core.config.MetricsConfiguration;
import org.apache.activemq.artemis.core.config.WildcardConfiguration;
import org.apache.activemq.artemis.core.config.impl.ConfigurationImpl;
import org.apache.activemq.artemis.core.config.impl.SecurityConfiguration;
@@ -44,7 +46,9 @@ import org.apache.activemq.artemis.core.server.ServerSession;
import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
import org.apache.activemq.artemis.core.server.plugin.ActiveMQServerConnectionPlugin;
import org.apache.activemq.artemis.core.server.plugin.ActiveMQServerSessionPlugin;
+import org.apache.activemq.artemis.core.settings.impl.AddressFullMessagePolicy;
import org.apache.activemq.artemis.core.settings.impl.AddressSettings;
+import org.apache.activemq.artemis.core.settings.impl.PageFullMessagePolicy;
import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
import org.apache.activemq.artemis.spi.core.security.jaas.GuestLoginModule;
import org.apache.activemq.artemis.spi.core.security.jaas.PrincipalConversionLoginModule;
@@ -80,7 +84,7 @@ import java.security.Principal;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@@ -92,6 +96,7 @@ import static org.openremote.container.util.MapAccess.getString;
import static org.openremote.model.Constants.KEYCLOAK_CLIENT_ID;
import static org.openremote.model.syslog.SyslogCategory.API;
+// TODO: Add queue size limiting in canPublish of MQTTHandlers (needs to be done at auth time to allow pub to be rejected)
public class MQTTBrokerService extends RouteBuilder implements ContainerService, ActiveMQServerConnectionPlugin, ActiveMQServerSessionPlugin {
public static final String MQTT_FORCE_USER_DISCONNECT_DEBOUNCE_MILLIS = "MQTT_FORCE_USER_DISCONNECT_DEBOUNCE_MILLIS";
@@ -108,7 +113,7 @@ public class MQTTBrokerService extends RouteBuilder implements ContainerService,
protected ManagerKeycloakIdentityProvider identityProvider;
protected ClientEventService clientEventService;
protected MessageBrokerService messageBrokerService;
- protected ScheduledExecutorService executorService;
+ protected ExecutorService executorService;
protected TimerService timerService;
protected AssetProcessingService assetProcessingService;
protected List<MQTTHandler> customHandlers = new ArrayList<>();
@@ -142,11 +147,11 @@ public class MQTTBrokerService extends RouteBuilder implements ContainerService,
clientEventService = container.getService(ClientEventService.class);
ManagerIdentityService identityService = container.getService(ManagerIdentityService.class);
messageBrokerService = container.getService(MessageBrokerService.class);
- executorService = container.getExecutorService();
+ executorService = container.getExecutor();
timerService = container.getService(TimerService.class);
assetProcessingService = container.getService(AssetProcessingService.class);
- userAssetDisconnectDebouncer = new Debouncer<>(executorService, id -> processUserAssetLinkChange(id, userAssetLinkChangeMap.remove(id)), debounceMillis);
+ userAssetDisconnectDebouncer = new Debouncer<>(container.getScheduledExecutor(), id -> processUserAssetLinkChange(id, userAssetLinkChangeMap.remove(id)), debounceMillis);
// This allows last will messages to be processed
disconnectedConnectionCache = CacheBuilder.newBuilder()
.maximumSize(10000)
@@ -172,7 +177,16 @@ public class MQTTBrokerService extends RouteBuilder implements ContainerService,
.build().toString();
serverConfiguration.addAcceptorConfiguration("tcp", serverURI);
serverConfiguration.registerBrokerPlugin(this);
+ if (container.getMeterRegistry() != null) {
+ serverConfiguration.setMetricsConfiguration(new MetricsConfiguration().setJvmMemory(false).setPlugin(new org.apache.activemq.artemis.core.server.metrics.plugins.SimpleMetricsPlugin() {
+ @Override
+ public MeterRegistry getRegistry() {
+ return container.getMeterRegistry();
+ }
+ }));
+ }
serverConfiguration.setWildCardConfiguration(wildcardConfiguration);
+ serverConfiguration.setLiteralMatchMarkers("()");
// Configure global address settings - aggressively cleanup queues (don't support resumable sessions)
serverConfiguration.addAddressSetting(wildcardConfiguration.getAnyWordsString(),
@@ -184,10 +198,27 @@ public class MQTTBrokerService extends RouteBuilder implements ContainerService,
// Auto delete MQTT addresses after 1 day as they never get flagged as used so will linger otherwise
.setAutoDeleteAddressesSkipUsageCheck(true)
.setAutoDeleteAddressesDelay(86400000)
- .setAutoDeleteQueuesDelay(0)
.setAutoDeleteQueuesMessageCount(-1L)
+ .setAutoDeleteQueuesDelay(0)
+ // This has a negative impact on performance if set to 0
+ .setDefaultConsumerWindowSize(-1)
+ .setPageLimitMessages(0L)
+ .setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL)
+ .setPageFullMessagePolicy(PageFullMessagePolicy.FAIL)
+ // We don't want excessive metrics so only enable metrics for each custom handler address
+ .setEnableMetrics(false)
);
+ // The below is an example of rate limiting at the address level the FAIL policy will cause an exception
+ // that is handled by the MQTTProtocolHandler which will disconnect the client (MQTT doesn't have a nice
+ // way of handling rejected publishes)
+// serverConfiguration.addAddressSetting("*.*.writeattributevalue.#",
+// new AddressSettings()
+// .setMaxSizeMessages(3)
+// .setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL)
+// .setMaxSizeBytes(1L)
+// );
+
serverConfiguration.setPersistenceEnabled(false);
// TODO: Make auto provisioning clients disconnect and reconnect with credentials or pass through X.509 certificates for auth
@@ -407,11 +438,10 @@ public class MQTTBrokerService extends RouteBuilder implements ContainerService,
public void onSubscribe(RemotingConnection connection, String topicStr) {
Topic topic = Topic.parse(topicStr);
-
+ LOG.log(TRACE, () -> "onSubscribe '" + topicStr + "': " + connectionToString(connection));
for (MQTTHandler handler : getCustomHandlers()) {
if (handler.handlesTopic(topic)) {
- String connectionStr = LOG.isLoggable(DEBUG) ? connectionToString(connection) : null;
- LOG.log(DEBUG, "Client subscribed '" + topicStr + "': " + connectionStr);
+ LOG.log(DEBUG, () -> "Client subscribed '" + topicStr + "': " + connectionToString(connection));
handler.onSubscribe(connection, topic);
break;
}
@@ -420,11 +450,10 @@ public class MQTTBrokerService extends RouteBuilder implements ContainerService,
public void onUnsubscribe(RemotingConnection connection, String topicStr) {
Topic topic = Topic.parse(topicStr);
-
+ LOG.log(TRACE, () -> "onUnsubscribe '" + topicStr + "': " + connectionToString(connection));
for (MQTTHandler handler : getCustomHandlers()) {
if (handler.handlesTopic(topic)) {
- String connectionStr = LOG.isLoggable(DEBUG) ? connectionToString(connection) : null;
- LOG.log(DEBUG, "Client unsubscribed '" + topicStr + "': " + connectionStr);
+ LOG.log(DEBUG, () -> "Client unsubscribed '" + topicStr + "': " + connectionToString(connection));
handler.onUnsubscribe(connection, topic);
break;
}
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/MQTTHandler.java b/manager/src/main/java/org/openremote/manager/mqtt/MQTTHandler.java
index 67be395da..b3809420b 100644
--- a/manager/src/main/java/org/openremote/manager/mqtt/MQTTHandler.java
+++ b/manager/src/main/java/org/openremote/manager/mqtt/MQTTHandler.java
@@ -29,6 +29,7 @@ import org.apache.activemq.artemis.api.core.client.ClientProducer;
import org.apache.activemq.artemis.api.core.client.ClientSession;
import org.apache.activemq.artemis.core.config.Configuration;
import org.apache.activemq.artemis.core.protocol.mqtt.MQTTUtil;
+import org.apache.activemq.artemis.core.settings.impl.AddressSettings;
import org.apache.activemq.artemis.reader.MessageUtil;
import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
import org.keycloak.KeycloakSecurityContext;
@@ -36,6 +37,7 @@ import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.security.AuthContext;
import org.openremote.container.security.keycloak.AccessTokenAuthContext;
import org.openremote.container.security.keycloak.KeycloakIdentityProvider;
+import org.openremote.container.timer.TimerService;
import org.openremote.manager.event.ClientEventService;
import org.openremote.manager.security.ManagerIdentityService;
import org.openremote.manager.security.ManagerKeycloakIdentityProvider;
@@ -49,13 +51,11 @@ import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutorService;
import java.util.logging.Level;
import java.util.logging.Logger;
-import static java.lang.System.Logger.Level.TRACE;
-import static java.lang.System.Logger.Level.WARNING;
import static org.apache.activemq.artemis.core.protocol.mqtt.MQTTUtil.MQTT_QOS_LEVEL_KEY;
-import static org.openremote.manager.mqtt.MQTTBrokerService.LOG;
/**
* This allows custom handlers to be discovered by the {@link MQTTBrokerService} during system startup using the
@@ -70,6 +70,8 @@ public abstract class MQTTHandler {
protected MQTTBrokerService mqttBrokerService;
protected MessageBrokerService messageBrokerService;
protected ManagerKeycloakIdentityProvider identityProvider;
+ protected ExecutorService executorService;
+ protected TimerService timerService;
protected boolean isKeycloak;
protected ClientSession clientSession;
protected ClientProducer producer;
@@ -97,6 +99,8 @@ public abstract class MQTTHandler {
clientEventService = container.getService(ClientEventService.class);
messageBrokerService = container.getService(MessageBrokerService.class);
ManagerIdentityService identityService = container.getService(ManagerIdentityService.class);
+ executorService = container.getExecutor();
+ timerService = container.getService(TimerService.class);
if (!identityService.isKeycloakEnabled()) {
getLogger().warning("MQTT connections are not supported when not using Keycloak identity provider");
@@ -105,6 +109,8 @@ public abstract class MQTTHandler {
isKeycloak = true;
identityProvider = (ManagerKeycloakIdentityProvider) identityService.getIdentityProvider();
}
+
+ addPublishTopicServerConfiguration(container, serverConfiguration);
}
/**
@@ -135,11 +141,37 @@ public abstract class MQTTHandler {
}
}
+ protected void addPublishTopicServerConfiguration(Container container, Configuration serverConfiguration) {
+ Set<String> publishListenerTopics = getPublishListenerTopics();
+ if (publishListenerTopics != null) {
+ publishListenerTopics.forEach(topic -> {
+ String coreTopic = MQTTUtil.getCoreAddressFromMqttTopic(topic, mqttBrokerService.wildcardConfiguration);
+ // Use literal address to avoid wildcard matching to other addresses
+ AddressSettings addressSettings = getPublishTopicAddressSettings(container, topic);
+ if (addressSettings != null) {
+ serverConfiguration.addAddressSetting("(" + coreTopic + ")", addressSettings);
+ }
+ });
+ }
+ }
+
+ /**
+ * Just enable metrics on the topic by default but allow custom handlers to add more configuration as required
+ */
+ protected AddressSettings getPublishTopicAddressSettings(Container container, String publishTopic) {
+ if (container.getMeterRegistry() != null) {
+ return new AddressSettings()
+ .setEnableMetrics(true);
+ }
+
+ return null;
+ }
+
protected void addPublishConsumer(String topic) throws Exception {
try {
getLogger().info("Adding publish consumer for topic '" + topic + "': handler=" + getName());
String coreTopic = MQTTUtil.getCoreAddressFromMqttTopic(topic, mqttBrokerService.wildcardConfiguration);
- clientSession.createQueue(QueueConfiguration.of(coreTopic).setRoutingType(RoutingType.MULTICAST).setPurgeOnNoConsumers(true).setAutoCreateAddress(true).setAutoCreated(true));
+ clientSession.createQueue(QueueConfiguration.of(coreTopic).setDurable(false).setRoutingType(RoutingType.MULTICAST).setPurgeOnNoConsumers(true).setAutoCreateAddress(true).setAutoCreated(true));
ClientConsumer consumer = clientSession.createConsumer(coreTopic);
consumer.setMessageHandler(message -> {
Topic publishTopic = Topic.parse(MQTTUtil.getMqttTopicFromCoreAddress(message.getAddress(), mqttBrokerService.wildcardConfiguration));
@@ -150,15 +182,20 @@ public abstract class MQTTHandler {
// Need to be able to get connection/auth from the message somehow
// Cannot use connection.getTransportConnection().isOpen() check as well due to last will publishes
if (connection == null) {
- LOG.log(TRACE, "Client is no longer connected so dropping publish to topic '" + topic + "': clientID=" + clientID);
+ getLogger().finer(() -> "Client is no longer connected so dropping publish to topic '" + topic + "': clientID=" + clientID);
return;
}
- getLogger().fine(() -> "Client published to '" + publishTopic + "': " + MQTTBrokerService.connectionToString(connection));
- onPublish(connection, publishTopic, message.getReadOnlyBodyBuffer().byteBuf());
+ getLogger().finer(() -> "onPublish '" + publishTopic + "': " + MQTTBrokerService.connectionToString(connection));
+
+ try {
+ onPublish(connection, publishTopic, message.getReadOnlyBodyBuffer().byteBuf());
+ } catch (Exception e) {
+ getLogger().info("An error occurred whilst handling onPublish to topic '" + topic + "': clientID=" + clientID);
+ }
});
} catch (Exception e) {
- getLogger().log(Level.WARNING, "Failed to create handler consumer for topic '" + topic + "': handler=" + getName(), e);
+ getLogger().log(Level.SEVERE, "Failed to create handler consumer for topic '" + topic + "': handler=" + getName(), e);
throw e;
}
}
@@ -199,11 +236,9 @@ public abstract class MQTTHandler {
*/
public boolean handlesTopic(Topic topic) {
if (!topicTokenCountGreaterThan(topic, 2)) {
- getLogger().finest("Topic must contain more than 2 tokens");
return false;
}
if (!topicMatches(topic)) {
- getLogger().finest("Topic failed to match this handler");
return false;
}
return true;
@@ -261,7 +296,7 @@ public abstract class MQTTHandler {
}
}
} catch (Exception e) {
- LOG.log(WARNING, "Couldn't publish to MQTT client: topic=" + topic, e);
+ getLogger().log(Level.WARNING, "Couldn't publish to MQTT client: topic=" + topic, e);
}
}
diff --git a/manager/src/main/java/org/openremote/manager/mqtt/UserAssetProvisioningMQTTHandler.java b/manager/src/main/java/org/openremote/manager/mqtt/UserAssetProvisioningMQTTHandler.java
index 8be8e30a2..727c699ff 100644
--- a/manager/src/main/java/org/openremote/manager/mqtt/UserAssetProvisioningMQTTHandler.java
+++ b/manager/src/main/java/org/openremote/manager/mqtt/UserAssetProvisioningMQTTHandler.java
@@ -19,16 +19,15 @@
*/
package org.openremote.manager.mqtt;
+import io.micrometer.core.instrument.Tags;
+import io.micrometer.core.instrument.Timer;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.mqtt.MqttQoS;
import org.apache.activemq.artemis.core.config.Configuration;
-import org.apache.activemq.artemis.core.settings.impl.AddressFullMessagePolicy;
import org.apache.activemq.artemis.core.settings.impl.AddressSettings;
-import org.apache.activemq.artemis.core.settings.impl.PageFullMessagePolicy;
import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
import org.apache.camel.builder.RouteBuilder;
import org.keycloak.KeycloakSecurityContext;
-import org.openremote.container.concurrent.ContainerExecutor;
import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.timer.TimerService;
import org.openremote.manager.asset.AssetStorageService;
@@ -54,13 +53,13 @@ import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import java.util.*;
-import java.util.concurrent.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import static org.openremote.container.persistence.PersistenceService.PERSISTENCE_TOPIC;
import static org.openremote.container.persistence.PersistenceService.isPersistenceEventForEntityType;
-import static org.openremote.container.util.MapAccess.getInteger;
import static org.openremote.model.Constants.RESTRICTED_USER_REALM_ROLE;
import static org.openremote.model.syslog.SyslogCategory.API;
@@ -93,7 +92,7 @@ public class UserAssetProvisioningMQTTHandler extends MQTTHandler {
if (persistenceEvent.getCause() == PersistenceEvent.Cause.UPDATE) {
// Force disconnect if the certain properties have changed
forceDisconnect = persistenceEvent.hasPropertyChanged(ProvisioningConfig.DISABLED_PROPERTY_NAME)
- || persistenceEvent.hasPropertyChanged(ProvisioningConfig.DATA_PROPERTY_NAME);
+ || persistenceEvent.hasPropertyChanged(ProvisioningConfig.DATA_PROPERTY_NAME);
}
if (forceDisconnect) {
@@ -110,31 +109,21 @@ public class UserAssetProvisioningMQTTHandler extends MQTTHandler {
public static final String RESPONSE_TOKEN = "response";
public static final String UNIQUE_ID_PLACEHOLDER = "%UNIQUE_ID%";
public static final String PROVISIONING_USER_PREFIX = "ps-";
- public static final String OR_AUTO_PROVISIONING_THREADS_MIN = "OR_AUTO_PROVISIONING_THREADS_MIN";
- public static final String OR_AUTO_PROVISIONING_THREADS_MAX = "OR_AUTO_PROVISIONING_THREADS_MAX";
- public static final int OR_AUTO_PROVISIONING_MIN_THREAD_COUNT_DEFAULT = 1;
- public static final int OR_AUTO_PROVISIONING_MAX_THREAD_COUNT_DEFAULT = 10;
protected ProvisioningService provisioningService;
protected TimerService timerService;
protected AssetStorageService assetStorageService;
protected ManagerKeycloakIdentityProvider identityProvider;
protected boolean isKeycloak;
protected final ConcurrentMap<Long, Set<RemotingConnection>> provisioningConfigAuthenticatedConnectionMap = new ConcurrentHashMap<>();
- protected ExecutorService provisioningExecutorService;
+ protected Timer provisioningTimer;
@Override
public void init(Container container, Configuration serverConfiguration) throws Exception {
super.init(container, serverConfiguration);
- // Set all provisioning addresses to fail on full
- serverConfiguration.addAddressSetting(PROVISIONING_TOKEN + "." + mqttBrokerService.wildcardConfiguration.getAnyWordsString(),
- new AddressSettings()
- .setPageFullMessagePolicy(PageFullMessagePolicy.FAIL)
- .setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL)
- .setMaxSizeMessages(1000)
- .setPageLimitMessages(0L)
- .setDefaultConsumerWindowSize(-1)
- );
+ if (container.getMeterRegistry() != null) {
+ provisioningTimer = container.getMeterRegistry().timer("or.provisioning", Tags.empty());
+ }
}
@Override
@@ -152,12 +141,21 @@ public class UserAssetProvisioningMQTTHandler extends MQTTHandler {
isKeycloak = true;
identityProvider = (ManagerKeycloakIdentityProvider) identityService.getIdentityProvider();
container.getService(MessageBrokerService.class).getContext().addRoutes(new ProvisioningPersistenceRouteBuilder(this));
+ }
+ }
- int minThreadCount = getInteger(container.getConfig(), OR_AUTO_PROVISIONING_THREADS_MIN, OR_AUTO_PROVISIONING_MIN_THREAD_COUNT_DEFAULT);
- int maxThreadCount = Math.max(minThreadCount, getInteger(container.getConfig(), OR_AUTO_PROVISIONING_THREADS_MAX, OR_AUTO_PROVISIONING_MAX_THREAD_COUNT_DEFAULT));
-
- provisioningExecutorService = new ContainerExecutor("AutoProvisioningPool", minThreadCount, maxThreadCount, 60, -1, new ThreadPoolExecutor.CallerRunsPolicy());
+ /**
+ * Limit the number of messages allowed in the address queue and fail when over; this will disconnect the client.
+ * Approx 20ms per request with 20s timeout on auto provisioning request = 1000
+ */
+ @Override
+ protected AddressSettings getPublishTopicAddressSettings(Container container, String publishTopic) {
+ AddressSettings addressSettings = super.getPublishTopicAddressSettings(container, publishTopic);
+ if (addressSettings != null) {
+ addressSettings
+ .setMaxSizeMessages(1000L);
}
+ return addressSettings;
}
@Override
@@ -242,18 +240,21 @@ public class UserAssetProvisioningMQTTHandler extends MQTTHandler {
@Override
public void onPublish(RemotingConnection connection, Topic topic, ByteBuf body) {
// Offload messages to the thread pool to improve processing rate
- try {
- provisioningExecutorService.submit(() -> {
- if (!connection.getTransportConnection().isOpen()) {
- // Drop provisioning requests for closed connections
- LOG.fine(() -> "Skipping provisioning request as connection is now closed: " + MQTTBrokerService.connectionToString(connection));
- return;
- }
- this.processProvisioningRequest(connection, topic, body);
- });
- } catch (RejectedExecutionException e) {
- publishMessage(getResponseTopic(topic), new ErrorResponseMessage(ErrorResponseMessage.Error.SERVER_BUSY), MqttQoS.AT_MOST_ONCE);
+ if (!connection.getTransportConnection().isOpen()) {
+ // Drop provisioning requests for closed connections
+ LOG.finest(() -> "Skipping provisioning request as connection is now closed: " + MQTTBrokerService.connectionToString(connection));
+ return;
}
+ // When no more threads available in the executorService the calling ActiveMQ client thread will execute which
+ // will cause provisioning messages to wait in the address queue eventually hitting the message limit and
+ // additional requests will be failed until the queue drains, this provides natural rate limiting.
+ executorService.submit(() -> {
+ if (provisioningTimer != null) {
+ provisioningTimer.record(() -> processProvisioningRequest(connection, topic, body));
+ } else {
+ processProvisioningRequest(connection, topic, body);
+ }
+ });
}
@Override
@@ -403,7 +404,7 @@ public class UserAssetProvisioningMQTTHandler extends MQTTHandler {
return connections;
});
- LOG.fine("Client successfully provisioned");
+ LOG.fine("Client successfully provisioned: " + uniqueId);
publishMessage(getResponseTopic(topic), new SuccessResponseMessage(realm, asset), MqttQoS.AT_MOST_ONCE);
}
diff --git a/manager/src/main/java/org/openremote/manager/notification/EmailNotificationHandler.java b/manager/src/main/java/org/openremote/manager/notification/EmailNotificationHandler.java
index 9eb2e9556..2888f094d 100644
--- a/manager/src/main/java/org/openremote/manager/notification/EmailNotificationHandler.java
+++ b/manager/src/main/java/org/openremote/manager/notification/EmailNotificationHandler.java
@@ -98,7 +98,7 @@ public class EmailNotificationHandler implements NotificationHandler {
boolean startTls = getBoolean(container.getConfig(), OR_EMAIL_TLS, OR_EMAIL_TLS_DEFAULT);
String protocol = startTls ? "smtp" : getString(container.getConfig(), OR_EMAIL_PROTOCOL, OR_EMAIL_PROTOCOL_DEFAULT);
MailClientBuilder mailClientBuilder = new MailClientBuilder(
- container.getExecutorService(), protocol, host, port
+ container.getExecutor(), container.getScheduledExecutor(), protocol, host, port
);
// Add authentication
diff --git a/manager/src/main/java/org/openremote/manager/notification/NotificationService.java b/manager/src/main/java/org/openremote/manager/notification/NotificationService.java
index 2c6727709..c48fc1cc5 100644
--- a/manager/src/main/java/org/openremote/manager/notification/NotificationService.java
+++ b/manager/src/main/java/org/openremote/manager/notification/NotificationService.java
@@ -46,6 +46,7 @@ import org.openremote.model.util.TimeUtil;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.*;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -60,13 +61,14 @@ import static org.openremote.model.notification.Notification.Source.*;
public class NotificationService extends RouteBuilder implements ContainerService {
- public static final String NOTIFICATION_QUEUE = "seda://NotificationQueue?waitForTaskToComplete=IfReplyExpected&timeout=10000&purgeWhenStopping=true&discardIfNoConsumers=false&size=25000";
+ public static final String NOTIFICATION_QUEUE = "direct://NotificationQueue";
private static final Logger LOG = Logger.getLogger(NotificationService.class.getName());
protected TimerService timerService;
protected PersistenceService persistenceService;
protected AssetStorageService assetStorageService;
protected ManagerIdentityService identityService;
protected MessageBrokerService messageBrokerService;
+ protected ExecutorService executorService;
protected Map<String, NotificationHandler> notificationHandlerMap = new HashMap<>();
@Override
@@ -81,6 +83,7 @@ public class NotificationService extends RouteBuilder implements ContainerServic
this.assetStorageService = container.getService(AssetStorageService.class);
this.identityService = container.getService(ManagerIdentityService.class);
this.messageBrokerService = container.getService(MessageBrokerService.class);
+ executorService = container.getExecutor();
container.getService(MessageBrokerService.class).getContext().addRoutes(this);
container.getServices(NotificationHandler.class).forEach(notificationHandler ->
@@ -109,6 +112,7 @@ public class NotificationService extends RouteBuilder implements ContainerServic
from(NOTIFICATION_QUEUE)
.routeId("NotificationQueue")
+ .threads().executorService(executorService)
.process(exchange -> {
Notification notification = exchange.getIn().getBody(Notification.class);
diff --git a/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java b/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java
index 1a797a53b..5167a0020 100644
--- a/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java
+++ b/manager/src/main/java/org/openremote/manager/rules/JsonRulesBuilder.java
@@ -19,10 +19,10 @@
*/
package org.openremote.manager.rules;
-import org.openremote.model.PersistenceEvent;
import jakarta.ws.rs.core.MediaType;
import org.openremote.container.timer.TimerService;
import org.openremote.manager.asset.AssetStorageService;
+import org.openremote.model.PersistenceEvent;
import org.openremote.model.alarm.Alarm;
import org.openremote.model.asset.Asset;
import org.openremote.model.asset.UserAssetLink;
@@ -51,7 +51,7 @@ import org.shredzone.commons.suncalc.SunTimes;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoUnit;
import java.util.*;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
@@ -228,6 +228,15 @@ public class JsonRulesBuilder extends RulesBuilder {
}
}
+ // Replace any potentially stale asset states (values may have changed)
+ // only need up to date values in the previously matched asset states previously unmatched asset states is only
+ // used to compare asset ID and attribute name.
+ if (event != null) {
+ if (previouslyMatchedAssetStates.remove(event.assetState)) {
+ previouslyMatchedAssetStates.add(event.assetState);
+ }
+ }
+
// During startup notify RulesFacts about any location predicates
if (facts.trackLocationRules) {
facts.storeLocationPredicates(getLocationPredicates(attributePredicates));
@@ -540,22 +549,19 @@ public class JsonRulesBuilder extends RulesBuilder {
final protected Alarms alarmsFacade;
final protected HistoricDatapoints historicDatapointsFacade;
final protected PredictedDatapoints predictedDatapointsFacade;
- final protected ScheduledExecutorService executorService;
final protected BiConsumer<Runnable, Long> scheduledActionConsumer;
- final protected Map<String, RuleState> ruleStateMap = new HashMap<>();
+ final protected Map<String, RuleState> ruleStateMap = new ConcurrentHashMap<>();
final protected JsonRule[] jsonRules;
final protected Ruleset jsonRuleset;
protected static Logger LOG;
- public JsonRulesBuilder(Logger logger, Ruleset ruleset, RulesEngine<?> rulesEngine, TimerService timerService,
- AssetStorageService assetStorageService, ScheduledExecutorService executorService,
+ public JsonRulesBuilder(Logger logger, Ruleset ruleset, RulesEngine<?> rulesEngine, TimerService timerService, AssetStorageService assetStorageService,
Assets assetsFacade, Users usersFacade, Notifications notificationsFacade, Webhooks webhooksFacade,
Alarms alarmsFacade, HistoricDatapoints historicDatapoints, PredictedDatapoints predictedDatapoints,
BiConsumer<Runnable, Long> scheduledActionConsumer) throws Exception {
this.rulesEngine = rulesEngine;
this.timerService = timerService;
this.assetStorageService = assetStorageService;
- this.executorService = executorService;
this.assetsFacade = assetsFacade;
this.usersFacade = usersFacade;
this.notificationsFacade = notificationsFacade;
@@ -676,12 +682,12 @@ public class JsonRulesBuilder extends RulesBuilder {
// Execute actions only when the rules engine has already fired to prevent execution during startup
if (rulesEngine.hasPreviouslyFired()) {
if (ruleState.thenMatched()) {
- log(Level.FINEST, "Triggered rule so executing 'then' actions for rule: " + rule.name);
+ log(Level.FINE, "Triggered rule so executing 'then' actions for rule: " + rule.name);
executeRuleActions(rule, rule.then, "then", false, facts, ruleState, assetsFacade, usersFacade, notificationsFacade, webhooksFacade, alarmsFacade, predictedDatapointsFacade, scheduledActionConsumer);
}
if (rule.otherwise != null && ruleState.otherwiseMatched()) {
- log(Level.FINEST, "Triggered rule so executing 'otherwise' actions for rule: " + rule.name);
+ log(Level.FINE, "Triggered rule so executing 'otherwise' actions for rule: " + rule.name);
executeRuleActions(rule, rule.otherwise, "otherwise", true, facts, ruleState, assetsFacade, usersFacade, notificationsFacade, webhooksFacade, alarmsFacade, predictedDatapointsFacade, scheduledActionConsumer);
}
}
@@ -706,10 +712,6 @@ public class JsonRulesBuilder extends RulesBuilder {
// Store last evaluation results in state
if (ruleConditionState.lastEvaluationResult != null) {
- // Replace any stale matched asset states (values may have changed equality is by asset ID and attribute name)
- // only need up to date values in the previously matched asset states previously unmatched asset states is only
- // used to compare asset ID and attribute name.
- ruleConditionState.previouslyMatchedAssetStates.removeAll(ruleConditionState.lastEvaluationResult.matchedAssetStates);
ruleConditionState.previouslyMatchedAssetStates.addAll(ruleConditionState.lastEvaluationResult.matchedAssetStates);
if (ruleConditionState.trackUnmatched) {
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
index 7301ac2ea..f8e95eb73 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
@@ -19,8 +19,6 @@
*/
package org.openremote.manager.rules;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.Tags;
import io.micrometer.core.instrument.Timer;
import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rule;
@@ -42,17 +40,13 @@ import org.openremote.manager.webhook.WebhookService;
import org.openremote.model.PersistenceEvent;
import org.openremote.model.asset.Asset;
import org.openremote.model.attribute.AttributeInfo;
-import org.openremote.model.attribute.AttributeRef;
import org.openremote.model.query.filter.GeofencePredicate;
import org.openremote.model.query.filter.LocationAttributePredicate;
import org.openremote.model.rules.*;
import org.openremote.model.syslog.SyslogCategory;
import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -101,7 +95,8 @@ public class RulesEngine<T extends Ruleset> {
public static final Logger STATS_LOG = Logger.getLogger("org.openremote.rules.RulesEngineStats");
final protected TimerService timerService;
final protected RulesService rulesService;
- final protected ScheduledExecutorService executorService;
+ final protected ExecutorService executorService;
+ final protected ScheduledExecutorService scheduledExecutorService;
final protected AssetStorageService assetStorageService;
final protected ClientEventService clientEventService;
@@ -126,6 +121,9 @@ public class RulesEngine<T extends Ruleset> {
protected boolean trackLocationPredicates;
protected ScheduledFuture<?> fireTimer;
protected ScheduledFuture<?> statsTimer;
+ protected final Set<AttributeInfo> updateInfos = new HashSet<>();
+ protected final Set<AttributeInfo> insertInfos = new HashSet<>();
+ protected final Set<AttributeInfo> retractInfos = new HashSet<>();
// Only used to optimize toString(), contains the details of this engine
protected String deploymentInfo;
@@ -134,7 +132,8 @@ public class RulesEngine<T extends Ruleset> {
public RulesEngine(TimerService timerService,
RulesService rulesService,
ManagerIdentityService identityService,
- ScheduledExecutorService executorService,
+ ExecutorService executorService,
+ ScheduledExecutorService scheduledExecutorService,
AssetStorageService assetStorageService,
AssetProcessingService assetProcessingService,
NotificationService notificationService,
@@ -145,13 +144,15 @@ public class RulesEngine<T extends Ruleset> {
AssetPredictedDatapointService assetPredictedDatapointService,
RulesEngineId<T> id,
AssetLocationPredicateProcessor assetLocationPredicatesConsumer,
- MeterRegistry meterRegistry) {
+ Timer rulesFiringTimer) {
this.timerService = timerService;
this.rulesService = rulesService;
this.previouslyFired = rulesService.startDone;
this.executorService = executorService;
+ this.scheduledExecutorService = scheduledExecutorService;
this.assetStorageService = assetStorageService;
this.clientEventService = clientEventService;
+ this.rulesFiringTimer = rulesFiringTimer;
this.id = id;
String ruleEngineCategory = id.scope.getSimpleName().replace("Ruleset", "Engine-") + id.getId().orElse("");
@@ -204,31 +205,12 @@ public class RulesEngine<T extends Ruleset> {
throw ex;
}
});
-
- if (meterRegistry != null) {
- meterRegistry.gauge("or.rules.facts", Tags.of("type", id.getScope().getSimpleName(), "id", getEngineId()), facts, (facts) -> (double) facts.getFactCount());
- rulesFiringTimer = meterRegistry.timer("or.rules.firing", Tags.of("type", id.getScope().getSimpleName(), "id", getEngineId()));
- }
}
public RulesEngineId<T> getId() {
return id;
}
- /**
- * @return a shallow copy of the asset state facts.
- */
- public synchronized Set<AttributeInfo> getAssetStates() {
- return new HashSet<>(facts.getAssetStates());
- }
-
- /**
- * @return a shallow copy of the asset event facts.
- */
- public synchronized List<TemporaryFact<AttributeInfo>> getAssetEvents() {
- return new ArrayList<>(facts.getAssetEvents());
- }
-
public boolean isRunning() {
return running;
}
@@ -277,7 +259,7 @@ public class RulesEngine<T extends Ruleset> {
removeRuleset(deployment.ruleset);
}
- deployment = new RulesetDeployment(ruleset, this, timerService, assetStorageService, executorService, assetsFacade, usersFacade, notificationFacade, webhooksFacade, alarmsFacade, historicFacade, predictedFacade);
+ deployment = new RulesetDeployment(ruleset, this, timerService, assetStorageService, executorService, scheduledExecutorService, assetsFacade, usersFacade, notificationFacade, webhooksFacade, alarmsFacade, historicFacade, predictedFacade);
deployment.init();
deployments.put(ruleset.getId(), deployment);
publishRulesetStatus(deployment);
@@ -311,8 +293,11 @@ public class RulesEngine<T extends Ruleset> {
}
public void start() {
- if (running) {
- return;
+ synchronized (this) {
+ if (running) {
+ return;
+ }
+ running = true;
}
if (deployments.isEmpty()) {
@@ -328,7 +313,6 @@ public class RulesEngine<T extends Ruleset> {
}
LOG.info("Starting: " + id);
- running = true;
trackLocationPredicates(true);
deployments.values().forEach(this::startRuleset);
@@ -344,15 +328,14 @@ public class RulesEngine<T extends Ruleset> {
} else {
LOG.info("Enabling periodic full memory dump at FINE level every 30 seconds on category: " + STATS_LOG.getName());
}
- statsTimer = executorService.scheduleAtFixedRate(this::printSessionStats, 3, 30, TimeUnit.SECONDS);
+ statsTimer = scheduledExecutorService.scheduleAtFixedRate(this::printSessionStats, 3, 30, TimeUnit.SECONDS);
}
}
- protected synchronized void trackLocationPredicates(boolean track) {
+ protected void trackLocationPredicates(boolean track) {
if (trackLocationPredicates == track) {
return;
}
-
trackLocationPredicates = track;
if (track) {
facts.startTrackingLocationRules();
@@ -364,10 +347,13 @@ public class RulesEngine<T extends Ruleset> {
}
public void stop() {
- if (!running) {
- return;
+ synchronized (this) {
+ if (!running) {
+ return;
+ }
+ running = false;
}
- running = false;
+
LOG.info("Stopping: " + id);
if (fireTimer != null) {
fireTimer.cancel(true);
@@ -387,19 +373,25 @@ public class RulesEngine<T extends Ruleset> {
publishRulesEngineStatus();
}
- protected synchronized void startRuleset(RulesetDeployment deployment) {
+ @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
+ protected void startRuleset(RulesetDeployment deployment) {
if (!running) {
return;
}
- if (deployment.start(facts)) {
- publishRulesetStatus(deployment);
+ synchronized (this) {
+ if (deployment.start(facts)) {
+ publishRulesetStatus(deployment);
+ }
}
}
- protected synchronized void stopRuleset(RulesetDeployment deployment) {
- if (deployment.stop(facts)) {
- publishRulesetStatus(deployment);
+ @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
+ protected void stopRuleset(RulesetDeployment deployment) {
+ synchronized (this) {
+ if (deployment.stop(facts)) {
+ publishRulesetStatus(deployment);
+ }
}
}
@@ -430,14 +422,15 @@ public class RulesEngine<T extends Ruleset> {
long fireTimeMillis = quickFire ? rulesService.quickFireMillis : rulesService.tempFactExpirationMillis;
LOG.finest("Scheduling rules firing in " + fireTimeMillis + "ms");
- fireTimer = executorService.schedule(
+ fireTimer = scheduledExecutorService.schedule(
() -> {
- synchronized (RulesEngine.this) {
- // Process rules for all deployments
- fireAllDeployments();
- fireTimer = null;
- scheduleFire(false);
+ fireTimer = null;
+ if (!running) {
+ return;
}
+ // Process rules for all deployments
+ fireAllDeployments();
+ scheduleFire(false);
},
fireTimeMillis,
TimeUnit.MILLISECONDS
@@ -449,6 +442,33 @@ public class RulesEngine<T extends Ruleset> {
return;
}
+ // Synchronise attribute events and states
+ synchronized (insertInfos) {
+
+ retractInfos.forEach(attributeInfo -> {
+ facts.removeAssetState(attributeInfo);
+ // Make sure location predicate tracking is activated before notifying the deployments otherwise they won't report location predicates
+ trackLocationPredicates(trackLocationPredicates || attributeInfo.getName().equals(Asset.LOCATION.getName()));
+ notifyAssetStatesChanged(new AssetStateChangeEvent(PersistenceEvent.Cause.DELETE, attributeInfo));
+ });
+
+ insertInfos.forEach(attributeInfo -> {
+ facts.putAssetState(attributeInfo);
+ // Make sure location predicate tracking is activated before notifying the deployments otherwise they won't report location predicates
+ trackLocationPredicates(trackLocationPredicates || attributeInfo.getName().equals(Asset.LOCATION.getName()));
+ notifyAssetStatesChanged(new AssetStateChangeEvent(PersistenceEvent.Cause.CREATE, attributeInfo));
+ });
+
+ updateInfos.forEach(attributeInfo -> {
+ facts.putAssetState(attributeInfo);
+ notifyAssetStatesChanged(new AssetStateChangeEvent(PersistenceEvent.Cause.UPDATE, attributeInfo));
+ });
+
+ insertInfos.clear();
+ updateInfos.clear();
+ retractInfos.clear();
+ }
+
if (trackLocationPredicates && assetLocationPredicatesConsumer != null) {
facts.startTrackingLocationRules();
}
@@ -492,6 +512,7 @@ public class RulesEngine<T extends Ruleset> {
facts.reset();
long startTimestamp = timerService.getCurrentTimeMillis();
+
engine.fire(deployment.getRules(), facts);
long executionMillis = (timerService.getCurrentTimeMillis() - startTimestamp);
LOG.fine("Rules deployment '" + deployment.getName() + "' executed in: " + executionMillis + "ms");
@@ -528,7 +549,7 @@ public class RulesEngine<T extends Ruleset> {
return id.realm + ":" + id.assetId;
}
- protected synchronized void notifyAssetStatesChanged(AssetStateChangeEvent event) {
+ protected void notifyAssetStatesChanged(AssetStateChangeEvent event) {
for (RulesetDeployment deployment : deployments.values()) {
if (!deployment.isError()) {
deployment.onAssetStatesChanged(facts, event);
@@ -536,37 +557,39 @@ public class RulesEngine<T extends Ruleset> {
}
}
- public synchronized void updateOrInsertAttributeInfo(AttributeInfo attributeInfo, boolean insert) {
- facts.putAssetState(attributeInfo);
- // Make sure location predicate tracking is activated before notifying the deployments otherwise they won't report location predicates
- trackLocationPredicates(trackLocationPredicates || (insert && attributeInfo.getName().equals(Asset.LOCATION.getName())));
- notifyAssetStatesChanged(new AssetStateChangeEvent(insert ? PersistenceEvent.Cause.CREATE : PersistenceEvent.Cause.UPDATE, attributeInfo));
- if (running) {
- scheduleFire(true);
+ public void insertOrUpdateAttributeInfo(AttributeInfo attributeInfo, boolean insert) {
+
+ synchronized (insertInfos) {
+ insert = insert || insertInfos.remove(attributeInfo);
+ updateInfos.remove(attributeInfo);
+ retractInfos.remove(attributeInfo);
+
+ if (insert) {
+ insertInfos.add(attributeInfo);
+ } else {
+ updateInfos.add(attributeInfo);
+ }
}
- }
- public synchronized void removeAttributeInfo(AttributeInfo attributeInfo) {
- facts.removeAssetState(attributeInfo);
- // Make sure location predicate tracking is activated before notifying the deployments otherwise they won't report location predicates
- trackLocationPredicates(trackLocationPredicates || attributeInfo.getName().equals(Asset.LOCATION.getName()));
- notifyAssetStatesChanged(new AssetStateChangeEvent(PersistenceEvent.Cause.DELETE, attributeInfo));
if (running) {
scheduleFire(true);
}
}
- public synchronized void insertAttributeEvent(long expiresMillis, AttributeInfo attributeInfo) {
- facts.insertAttributeEvent(expiresMillis, attributeInfo);
+ public void retractAttributeInfo(AttributeInfo attributeInfo) {
+
+ synchronized (insertInfos) {
+ insertInfos.remove(attributeInfo);
+ updateInfos.remove(attributeInfo);
+ retractInfos.remove(attributeInfo);
+ retractInfos.add(attributeInfo);
+ }
+
if (running) {
scheduleFire(true);
}
}
- public synchronized void removeAttributeEvents(AttributeRef attributeRef) {
- facts.removeAttributeEvents(attributeRef);
- }
-
protected void updateDeploymentInfo() {
deploymentInfo = Arrays.toString(
deployments.values().stream()
@@ -577,14 +600,12 @@ public class RulesEngine<T extends Ruleset> {
protected synchronized void printSessionStats() {
Collection<AttributeInfo> assetStateFacts = facts.getAssetStates();
- Collection<TemporaryFact<AttributeInfo>> assetEventFacts = facts.getAssetEvents();
Map<String, Object> namedFacts = facts.getNamedFacts();
Collection<Object> anonFacts = facts.getAnonymousFacts();
long temporaryFactsCount = facts.getTemporaryFacts().count();
- long total = assetStateFacts.size() + assetEventFacts.size() + namedFacts.size() + anonFacts.size();
+ long total = assetStateFacts.size() + namedFacts.size() + anonFacts.size();
STATS_LOG.fine("Engine stats for '" + this + "', in memory facts are Total: " + total
+ ", AssetState: " + assetStateFacts.size()
- + ", AssetEvent: " + assetEventFacts.size()
+ ", Named: " + namedFacts.size()
+ ", Anonymous: " + anonFacts.size()
+ ", Temporary: " + temporaryFactsCount);
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesFacts.java b/manager/src/main/java/org/openremote/manager/rules/RulesFacts.java
index d691b6966..c71d2d198 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesFacts.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesFacts.java
@@ -26,10 +26,8 @@ import org.jeasy.rules.api.RuleListener;
import org.openremote.container.timer.TimerService;
import org.openremote.manager.asset.AssetStorageService;
import org.openremote.model.asset.Asset;
-import org.openremote.model.asset.AssetEvent;
import org.openremote.model.attribute.AttributeEvent;
import org.openremote.model.attribute.AttributeInfo;
-import org.openremote.model.attribute.AttributeRef;
import org.openremote.model.query.AssetQuery;
import org.openremote.model.query.filter.GeofencePredicate;
import org.openremote.model.rules.Assets;
@@ -50,6 +48,9 @@ import java.util.stream.StreamSupport;
import static org.openremote.model.query.filter.LocationAttributePredicate.getLocationPredicates;
+/**
+ * NOTE: THIS IS NOT THREADSAFE
+ */
public class RulesFacts extends Facts implements RuleListener {
// Loop detection
@@ -59,7 +60,6 @@ public class RulesFacts extends Facts implements RuleListener {
public static final int INITIAL_CAPACITY = 100000;
public static final String ASSET_STATES = "INTERNAL_ASSET_STATES";
- public static final String ASSET_EVENTS = "INTERNAL_ASSET_EVENTS";
public static final String EXECUTION_VARS = "INTERNAL_EXECUTION_VAR";
public static final String ANONYMOUS_FACTS = "ANONYMOUS_FACTS";
@@ -68,8 +68,6 @@ public class RulesFacts extends Facts implements RuleListener {
final protected Assets assetsFacade;
final protected Object loggingContext;
final protected Logger LOG;
- final protected Map<String, Collection<AttributeInfo>> assetIdIndex = new HashMap<>();
- final protected Map<String, Collection<AttributeInfo>> assetTypeIndex = new HashMap<>();
protected int triggerCount;
protected boolean trackLocationRules;
protected Map<String, Set<GeofencePredicate>> assetStateLocationPredicateMap = null;
@@ -82,7 +80,6 @@ public class RulesFacts extends Facts implements RuleListener {
this.LOG = logger;
super.put(ASSET_STATES, new ArrayDeque<AttributeInfo>(INITIAL_CAPACITY));
- super.put(ASSET_EVENTS, new ArrayDeque<AssetEvent>(INITIAL_CAPACITY));
super.put(EXECUTION_VARS, new HashMap<>());
super.put(ANONYMOUS_FACTS, new ArrayDeque<>(INITIAL_CAPACITY));
}
@@ -109,11 +106,6 @@ public class RulesFacts extends Facts implements RuleListener {
return get(ASSET_STATES);
}
- @SuppressWarnings("unchecked")
- public Collection<TemporaryFact<AttributeInfo>> getAssetEvents() {
- return get(ASSET_EVENTS);
- }
-
@SuppressWarnings("unchecked")
public Collection<Object> getAnonymousFacts() {
return get(ANONYMOUS_FACTS);
@@ -122,7 +114,6 @@ public class RulesFacts extends Facts implements RuleListener {
public Map<String, Object> getNamedFacts() {
return asMap().entrySet().stream().filter(entry ->
!entry.getKey().equals(ASSET_STATES)
- && !entry.getKey().equals(ASSET_EVENTS)
&& !entry.getKey().equals(EXECUTION_VARS)
&& !entry.getKey().equals(ANONYMOUS_FACTS)
).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
@@ -130,20 +121,17 @@ public class RulesFacts extends Facts implements RuleListener {
public Stream<Object> getAllFacts() {
return
+ Stream.concat(
+ getNamedFacts().values().stream().parallel(),
Stream.concat(
- getNamedFacts().values().stream().parallel(),
- Stream.concat(
- getAnonymousFacts().stream().parallel(),
- Stream.concat(
- getAssetStates().stream().parallel(),
- getAssetEvents().stream().parallel()
- )
- )
- ).parallel();
+ getAnonymousFacts().stream().parallel(),
+ getAssetStates().stream().parallel()
+ )
+ ).parallel();
}
public long getFactCount() {
- return getNamedFacts().size() + getAnonymousFacts().size() + getAssetStates().size() + getAssetEvents().size();
+ return getNamedFacts().size() + getAnonymousFacts().size() + getAssetStates().size();
}
@SuppressWarnings("unchecked")
@@ -180,7 +168,6 @@ public class RulesFacts extends Facts implements RuleListener {
public <T> void put(String name, T fact) {
switch (name) {
case ANONYMOUS_FACTS:
- case ASSET_EVENTS:
case ASSET_STATES:
case EXECUTION_VARS:
throw new IllegalArgumentException("Reserved internal fact name: " + name);
@@ -207,16 +194,6 @@ public class RulesFacts extends Facts implements RuleListener {
getAssetStates().remove(assetState);
getAssetStates().add(assetState);
- // Maintain index of all asset states for this asset by ID
- assetIdIndex.putIfAbsent(assetState.getId(), new ArrayDeque<>());
- assetIdIndex.get(assetState.getId()).remove(assetState);
- assetIdIndex.get(assetState.getId()).add(assetState);
-
- // Maintain index of all asset states for this asset by type
- assetTypeIndex.putIfAbsent(assetState.getAssetType(), new ArrayDeque<>());
- assetTypeIndex.get(assetState.getAssetType()).remove(assetState);
- assetTypeIndex.get(assetState.getAssetType()).add(assetState);
-
return this;
}
@@ -226,35 +203,6 @@ public class RulesFacts extends Facts implements RuleListener {
}
getAssetStates().remove(assetState);
- // Maintain index of all asset states for this asset by ID
- Collection<AttributeInfo> assetIdIndexCollection = assetIdIndex.get(assetState.getId());
- if (assetIdIndexCollection != null) {
- assetIdIndexCollection.remove(assetState);
- }
-
- // Maintain index of all asset states for this asset by type
- Collection<AttributeInfo> assetTypeIndexCollection = assetTypeIndex.get(assetState.getAssetType());
- if (assetTypeIndexCollection != null) {
- assetTypeIndexCollection.remove(assetState);
- }
-
- return this;
- }
-
- public RulesFacts insertAttributeEvent(long expiresMilliSeconds, AttributeInfo attributeInfo) {
- TemporaryFact<AttributeInfo> fact = new TemporaryFact<>(attributeInfo.getTimestamp(), expiresMilliSeconds, attributeInfo);
- if (LOG.isLoggable(Level.FINEST)) {
- LOG.finest("Fact change (INSERT): " + fact + " - on: " + loggingContext);
- }
- getAssetEvents().add(fact);
- return this;
- }
-
- public RulesFacts removeAttributeEvents(AttributeRef attributeRef) {
- if (LOG.isLoggable(Level.FINEST)) {
- LOG.finest("Fact change (DELETE ALL): " + attributeRef + " on: " + loggingContext);
- }
- getAssetEvents().removeIf(fact -> fact.getFact().getRef().equals(attributeRef));
return this;
}
@@ -289,16 +237,13 @@ public class RulesFacts extends Facts implements RuleListener {
}
public boolean hasTemporaryFacts() {
- return getTemporaryFacts().count() > 0;
+ return getTemporaryFacts().findAny().isPresent();
}
public Stream<TemporaryFact<?>> getTemporaryFacts() {
return Stream.concat(
- Stream.concat(
- getAssetEvents().stream().parallel(),
- getNamedFacts().values().stream().parallel().filter(fact -> fact instanceof TemporaryFact<?>).map(fact -> (TemporaryFact<?>) fact)
- ),
- getAnonymousFacts().stream().parallel().filter(fact -> fact instanceof TemporaryFact<?>).map(fact -> (TemporaryFact<?>) fact)
+ getNamedFacts().values().stream().parallel().filter(fact -> fact instanceof TemporaryFact<?>).map(fact -> (TemporaryFact<?>) fact),
+ getAnonymousFacts().stream().parallel().filter(fact -> fact instanceof TemporaryFact<?>).map(fact -> (TemporaryFact<?>) fact)
).parallel();
}
@@ -364,8 +309,7 @@ public class RulesFacts extends Facts implements RuleListener {
protected <T> Optional<T> matchFact(Object fact, Class<T> factType, Predicate<T> predicate) {
if (fact == null)
return Optional.empty();
- if (fact instanceof TemporaryFact<?>) {
- TemporaryFact<?> temporaryFact = (TemporaryFact<?>) fact;
+ if (fact instanceof TemporaryFact<?> temporaryFact) {
fact = temporaryFact.getFact();
}
return Optional.ofNullable(
@@ -440,42 +384,29 @@ public class RulesFacts extends Facts implements RuleListener {
return assetStates.parallel().filter(p);
}
- public Optional<TemporaryFact<AttributeInfo>> matchFirstAssetEvent(AssetQuery assetQuery) {
- return matchAssetEvent(assetQuery).findFirst();
- }
-
- public Optional<TemporaryFact<AttributeInfo>> matchLastAssetEvent(AssetQuery assetQuery) {
- return matchAssetEvent(assetQuery).reduce((first, second) -> second);
- }
-
- @SuppressWarnings("unchecked")
- public Stream<TemporaryFact<AttributeInfo>> matchAssetEvent(AssetQuery assetQuery) {
- Predicate<AttributeInfo> p = new AssetQueryPredicate(timerService, assetStorageService, assetQuery);
- return getAssetEvents().stream().parallel()
- .filter(fact -> this.matchFact(fact, AttributeInfo.class, p).isPresent());
- }
-
+ @Deprecated
public RulesFacts updateAssetState(String assetId, String attributeName, Object value) {
- return invalidateAssetStateAndDispatch(assetId, attributeName, value);
+ // Dispatch the update to the asset processing service
+ AttributeEvent attributeEvent = new AttributeEvent(assetId, attributeName, value);
+ LOG.finest("Dispatching " + attributeEvent + " - on: " + loggingContext);
+ assetsFacade.dispatch(attributeEvent);
+ return this;
}
+ @Deprecated
public RulesFacts updateAssetState(String assetId, String attributeName) {
- return invalidateAssetStateAndDispatch(assetId, attributeName, null);
+ // Dispatch the update to the asset processing service
+ AttributeEvent attributeEvent = new AttributeEvent(assetId, attributeName, null);
+ LOG.finest("Dispatching " + attributeEvent + " - on: " + loggingContext);
+ assetsFacade.dispatch(attributeEvent);
+ return this;
}
public void removeExpiredTemporaryFacts() {
long currentTimestamp = timerService.getCurrentTimeMillis();
- getAssetEvents().removeIf(fact -> {
- boolean result = fact.isExpired(currentTimestamp);
- if (result && LOG.isLoggable(Level.FINEST)) {
- LOG.finest("Fact change (DELETE EXPIRED): " + fact + " - on: " + loggingContext);
- }
- return result;
- });
List<Fact<?>> expiredFacts = StreamSupport.stream(super.spliterator(), false).filter(fact -> {
if (fact.getName().equals(ASSET_STATES)
- || fact.getName().equals(ASSET_EVENTS)
|| fact.getName().equals(EXECUTION_VARS)
|| fact.getName().equals(ANONYMOUS_FACTS)
|| !(fact.getValue() instanceof TemporaryFact<?>)) {
@@ -487,14 +418,13 @@ public class RulesFacts extends Facts implements RuleListener {
LOG.finest("Fact change (DELETE EXPIRED): " + fact.getValue() + " - on: " + loggingContext);
}
return result;
- }).collect(Collectors.toList());
+ }).toList();
expiredFacts.forEach(this::remove);
getAnonymousFacts().removeIf(fact -> {
boolean result = false;
- if (fact instanceof TemporaryFact<?>) {
- TemporaryFact<?> temporaryFact = (TemporaryFact<?>) fact;
+ if (fact instanceof TemporaryFact<?> temporaryFact) {
result = temporaryFact.isExpired(timerService.getCurrentTimeMillis());
}
if (result && LOG.isLoggable(Level.FINEST)) {
@@ -511,7 +441,7 @@ public class RulesFacts extends Facts implements RuleListener {
}
boolean haveLog = false;
- if (getAllFacts().count() > 0) {
+ if (getAllFacts().findAny().isPresent()) {
logger.log(level, "--------------------------------- CLOCK ---------------------------------");
logger.log(level, Instant.ofEpochMilli(timerService.getCurrentTimeMillis()).toString());
haveLog = true;
@@ -519,33 +449,24 @@ public class RulesFacts extends Facts implements RuleListener {
List<AttributeInfo> sortedAssetStates = new ArrayList<>(getAssetStates());
sortedAssetStates.sort(Comparator.naturalOrder());
- if (sortedAssetStates.size() > 0) {
+ if (!sortedAssetStates.isEmpty()) {
logger.log(level, "--------------------------------- ASSET STATES (" + sortedAssetStates.size() + ") ---------------------------------");
for (AttributeInfo assetState : sortedAssetStates) {
logger.log(level, assetState.toString());
}
haveLog = true;
}
- List<TemporaryFact<AttributeInfo>> sortedAssetEvents = new ArrayList<>(getAssetEvents());
- if (sortedAssetEvents.size() > 0) {
- logger.log(level, "--------------------------------- ASSET EVENTS (" + sortedAssetEvents.size() + ") ---------------------------------");
- sortedAssetEvents.sort(Comparator.comparing(TemporaryFact::getTime));
- for (TemporaryFact<AttributeInfo> assetEvent : sortedAssetEvents) {
- logger.log(level, assetEvent.toString());
- }
- haveLog = true;
- }
Map<String, Object> namedFacts = getNamedFacts();
List<String> names = new ArrayList<>(namedFacts.keySet());
names.sort(Comparator.naturalOrder());
- if (names.size() > 0) {
+ if (!names.isEmpty()) {
logger.log(level, "--------------------------------- NAMED FACTS (" + names.size() + ") ---------------------------------");
for (String name : names) {
logger.log(level, String.format("%s => %s", name, namedFacts.get(name)));
}
haveLog = true;
}
- if (getAnonymousFacts().size() > 0) {
+ if (!getAnonymousFacts().isEmpty()) {
logger.log(level, "--------------------------------- ANONYMOUS FACTS (" + getAnonymousFacts().size() + ") ---------------------------------");
for (Object o : getAnonymousFacts()) {
logger.log(level, String.format("%s", o));
@@ -559,7 +480,7 @@ public class RulesFacts extends Facts implements RuleListener {
boolean haveLog = false;
List<String> sortedVars = new ArrayList<>(getVars().keySet());
sortedVars.sort(Comparator.naturalOrder());
- if (sortedVars.size() > 0) {
+ if (!sortedVars.isEmpty()) {
logger.info("--------------------------------- BOUND VARIABLES (" + sortedVars.size() + ") ---------------------------------");
for (String var : sortedVars) {
logger.info(String.format("%s => %s", var, getVars().get(var)));
@@ -578,21 +499,13 @@ public class RulesFacts extends Facts implements RuleListener {
Function<AttributeInfo, String> keyExtractor = AttributeInfo::getAssetName;
boolean reverse = orderBy.descending;
- switch (orderBy.property) {
-
- case CREATED_ON:
- keyExtractor = assetState -> Long.toString(assetState.getCreatedOn().getTime());
- break;
- case ASSET_TYPE:
- keyExtractor = AttributeInfo::getAssetType;
- break;
- case PARENT_ID:
- keyExtractor = AttributeInfo::getParentId;
- break;
- case REALM:
- keyExtractor = AttributeInfo::getRealm;
- break;
- }
+ keyExtractor = switch (orderBy.property) {
+ case CREATED_ON -> assetState -> Long.toString(assetState.getCreatedOn().getTime());
+ case ASSET_TYPE -> AttributeInfo::getAssetType;
+ case PARENT_ID -> AttributeInfo::getParentId;
+ case REALM -> AttributeInfo::getRealm;
+ default -> keyExtractor;
+ };
Comparator<AttributeInfo> comparator = Comparator.comparing(keyExtractor);
@@ -603,37 +516,6 @@ public class RulesFacts extends Facts implements RuleListener {
return comparator;
}
- protected RulesFacts invalidateAssetStateAndDispatch(String assetId, String attributeName, Object value) {
- // Remove the asset state from the facts, it is invalid now
- getAssetStates()
- .removeIf(assetState -> {
- boolean invalid = assetState.getId().equals(assetId) && assetState.getName().equals(attributeName);
- if (invalid) {
- if (LOG.isLoggable(Level.FINEST)) {
- LOG.finest("Fact change (INTERNAL DELETE): " + assetState + " - on: " + loggingContext);
- }
- // Maintain index of all asset states for this asset by ID
- Collection<AttributeInfo> assetIdIndexCollection = assetIdIndex.get(assetState.getId());
- if (assetIdIndexCollection != null) {
- assetIdIndexCollection.remove(assetState);
- }
- // Maintain index of all asset states for this asset by type
- Collection<AttributeInfo> assetTypeIndexCollection = assetTypeIndex.get(assetState.getAssetType());
- if (assetTypeIndexCollection != null) {
- assetTypeIndexCollection.remove(assetState);
- }
- }
- return invalid;
- });
-
- // Dispatch the update to the asset processing service
- AttributeEvent attributeEvent = new AttributeEvent(assetId, attributeName, value);
- LOG.finest("Dispatching " + attributeEvent + " - on: " + loggingContext);
- assetsFacade.dispatch(attributeEvent);
-
- return this;
- }
-
protected void storeLocationPredicates(List<GeofencePredicate> foundLocationPredicates) {
if (foundLocationPredicates != null && !foundLocationPredicates.isEmpty()) {
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesHealthStatusProvider.java b/manager/src/main/java/org/openremote/manager/rules/RulesHealthStatusProvider.java
index 3144c665e..b91980428 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesHealthStatusProvider.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesHealthStatusProvider.java
@@ -20,7 +20,6 @@
package org.openremote.manager.rules;
import org.openremote.model.Container;
-import org.openremote.model.ContainerService;
import org.openremote.model.rules.AssetRuleset;
import org.openremote.model.rules.RealmRuleset;
import org.openremote.model.system.HealthStatusProvider;
@@ -33,11 +32,6 @@ public class RulesHealthStatusProvider implements HealthStatusProvider {
public static final String NAME = "rules";
protected RulesService rulesService;
- @Override
- public int getPriority() {
- return ContainerService.DEFAULT_PRIORITY;
- }
-
@Override
public void init(Container container) throws Exception {
rulesService = container.getService(RulesService.class);
@@ -64,12 +58,13 @@ public class RulesHealthStatusProvider implements HealthStatusProvider {
int stoppedEngines = 0;
int errorEngines = 0;
- if (rulesService.globalEngine != null) {
+ RulesEngine<?> globalEngine = rulesService.globalEngine.get();
+ if (globalEngine != null) {
totalEngines++;
- if (!rulesService.globalEngine.isRunning()) {
+ if (!globalEngine.isRunning()) {
stoppedEngines++;
}
- if (rulesService.globalEngine.isError()) {
+ if (globalEngine.isError()) {
errorEngines++;
}
}
@@ -105,8 +100,9 @@ public class RulesHealthStatusProvider implements HealthStatusProvider {
objectValue.put("totalEngines", totalEngines);
objectValue.put("stoppedEngines", stoppedEngines);
objectValue.put("errorEngines", errorEngines);
- if (rulesService.globalEngine != null) {
- objectValue.put("global", getEngineHealthStatus(rulesService.globalEngine));
+
+ if (globalEngine != null) {
+ objectValue.put("global", getEngineHealthStatus(globalEngine));
}
objectValue.put("realm", realmEngines);
objectValue.put("asset", assetEngines);
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java b/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
index 627f6cae7..5afd389f5 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesResourceImpl.java
@@ -71,7 +71,7 @@ public class RulesResourceImpl extends ManagerWebResource implements RulesResour
throw new WebApplicationException(Response.Status.FORBIDDEN);
}
- return getEngineInfo(rulesService.globalEngine);
+ return getEngineInfo(rulesService.globalEngine.get());
}
@Override
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesService.java b/manager/src/main/java/org/openremote/manager/rules/RulesService.java
index 5f75fba3a..c6af4ba5f 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesService.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesService.java
@@ -19,13 +19,12 @@
*/
package org.openremote.manager.rules;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.binder.jvm.ExecutorServiceMetrics;
+import io.micrometer.core.instrument.Tags;
import org.apache.camel.builder.RouteBuilder;
-import org.openremote.container.concurrent.ContainerScheduledExecutor;
import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.persistence.PersistenceService;
import org.openremote.container.timer.TimerService;
+import org.openremote.manager.alarm.AlarmService;
import org.openremote.manager.asset.AssetProcessingException;
import org.openremote.manager.asset.AssetProcessingService;
import org.openremote.manager.asset.AssetStorageService;
@@ -35,7 +34,6 @@ import org.openremote.manager.event.AttributeEventInterceptor;
import org.openremote.manager.event.ClientEventService;
import org.openremote.manager.gateway.GatewayService;
import org.openremote.manager.notification.NotificationService;
-import org.openremote.manager.alarm.AlarmService;
import org.openremote.manager.rules.flow.FlowResourceImpl;
import org.openremote.manager.rules.geofence.GeofenceAssetAdapter;
import org.openremote.manager.security.ManagerIdentityService;
@@ -49,7 +47,6 @@ import org.openremote.model.asset.Asset;
import org.openremote.model.attribute.Attribute;
import org.openremote.model.attribute.AttributeEvent;
import org.openremote.model.attribute.AttributeInfo;
-import org.openremote.model.attribute.AttributeMap;
import org.openremote.model.query.AssetQuery;
import org.openremote.model.query.RulesetQuery;
import org.openremote.model.query.filter.LocationAttributePredicate;
@@ -65,13 +62,15 @@ import org.openremote.model.value.MetaItemType;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import java.util.stream.Stream;
+import static java.util.logging.Level.FINEST;
import static java.util.logging.Level.SEVERE;
import static org.openremote.container.persistence.PersistenceService.PERSISTENCE_TOPIC;
import static org.openremote.container.persistence.PersistenceService.isPersistenceEventForEntityType;
@@ -88,11 +87,6 @@ import static org.openremote.manager.gateway.GatewayService.isNotForGateway;
* sync with the asset state changes that occur. If an asset attribute value changes, the {@link AttributeInfo} in the
* rules engines will be updated to reflect the change.
* <p>
- * If an updated attribute's {@link MetaItemType#RULE_EVENT} is true, another temporary {@link AttributeInfo} fact is
- * inserted in the rules engines in scope. This fact expires automatically if the lifetime set in {@link
- * RulesService#OR_RULE_EVENT_EXPIRES} is reached, or if the lifetime set in the attribute {@link
- * MetaItemType#RULE_EVENT_EXPIRES} is reached.
- * <p>
* Each asset attribute update is processed in the following order:
* <ol>
* <li>Global Rulesets</li>
@@ -118,11 +112,14 @@ public class RulesService extends RouteBuilder implements ContainerService {
public static final String OR_RULES_QUICK_FIRE_MILLIS = "OR_RULES_QUICK_FIRE_MILLIS";
public static final int OR_RULES_QUICK_FIRE_MILLIS_DEFAULT = 3000;
private static final Logger LOG = Logger.getLogger(RulesService.class.getName());
+ protected final AtomicReference<RulesEngine<GlobalRuleset>> globalEngine = new AtomicReference<>();
protected final Map<String, RulesEngine<RealmRuleset>> realmEngines = new ConcurrentHashMap<>();
protected final Map<String, RulesEngine<AssetRuleset>> assetEngines = new ConcurrentHashMap<>();
+ protected static final Object ENGINE_LOCK = new Object();
protected List<GeofenceAssetAdapter> geofenceAssetAdapters = new ArrayList<>();
protected TimerService timerService;
- protected ScheduledExecutorService executorService;
+ protected ExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected PersistenceService persistenceService;
protected RulesetStorageService rulesetStorageService;
protected ManagerIdentityService identityService;
@@ -135,22 +132,21 @@ public class RulesService extends RouteBuilder implements ContainerService {
protected AssetPredictedDatapointService assetPredictedDatapointService;
protected ClientEventService clientEventService;
protected GatewayService gatewayService;
- protected RulesEngine<GlobalRuleset> globalEngine;
protected Realm[] realms;
protected AssetLocationPredicateProcessor locationPredicateRulesConsumer;
- protected final ConcurrentMap<RulesEngine<?>, List<RulesEngine.AssetLocationPredicates>> engineAssetLocationPredicateMap = new ConcurrentHashMap<>();
+ protected final Map<RulesEngine<?>, List<RulesEngine.AssetLocationPredicates>> engineAssetLocationPredicateMap = new ConcurrentHashMap<>();
protected final Set<String> assetsWithModifiedLocationPredicates = new HashSet<>();
// Keep global list of asset states that have been pushed to any engines
// The objects are already in memory inside the rule engines but keeping them
// here means we can quickly insert facts into newly started engines
- protected final Set<AttributeEvent> attributeEvents = new HashSet<>();
+ protected final Set<AttributeEvent> attributeEvents = ConcurrentHashMap.newKeySet();
protected final Set<AttributeEvent> preInitAttributeEvents = new HashSet<>();
protected long defaultEventExpiresMillis = 1000*60*60;
protected long tempFactExpirationMillis;
protected long quickFireMillis;
protected boolean initDone;
protected boolean startDone;
- protected MeterRegistry meterRegistry;
+ protected io.micrometer.core.instrument.Timer rulesFiringTimer;
@Override
public int getPriority() {
@@ -159,7 +155,8 @@ public class RulesService extends RouteBuilder implements ContainerService {
@Override
public void init(Container container) throws Exception {
- executorService = new ContainerScheduledExecutor(getClass().getSimpleName(), 1);
+ executorService = container.getExecutor();
+ scheduledExecutorService = container.getScheduledExecutor();
timerService = container.getService(TimerService.class);
persistenceService = container.getService(PersistenceService.class);
rulesetStorageService = container.getService(RulesetStorageService.class);
@@ -181,12 +178,6 @@ public class RulesService extends RouteBuilder implements ContainerService {
return;
}
- meterRegistry = container.getMeterRegistry();
-
- if (meterRegistry != null) {
- executorService = ExecutorServiceMetrics.monitor(meterRegistry, executorService, getClass().getSimpleName());
- }
-
clientEventService.addSubscriptionAuthorizer((realm, auth, subscription) -> {
if (subscription.isEventType(RulesEngineStatusEvent.class) || subscription.isEventType(RulesetChangedEvent.class)) {
@@ -212,7 +203,7 @@ public class RulesService extends RouteBuilder implements ContainerService {
return false;
});
- clientEventService.addInternalSubscription(AttributeEvent.class, null, this::onAttributeEvent);
+ clientEventService.addSubscription(AttributeEvent.class, null, this::onAttributeEvent);
ServiceLoader.load(GeofenceAssetAdapter.class).forEach(geofenceAssetAdapter -> {
LOG.fine("Adding GeofenceAssetAdapter: " + geofenceAssetAdapter.getClass().getName());
@@ -239,6 +230,10 @@ public class RulesService extends RouteBuilder implements ContainerService {
)
);
+ if (container.getMeterRegistry() != null) {
+ rulesFiringTimer = container.getMeterRegistry().timer("or.rules", Tags.empty());
+ }
+
initDone = true;
}
@@ -340,23 +335,25 @@ public class RulesService extends RouteBuilder implements ContainerService {
ruleAttribute.getTimestamp().orElse(0L),
ruleAttribute.getValue().orElse(null),
ruleAttribute.getTimestamp().orElse(0L));
- updateAttributeEvent(attributeEvent);
+ insertOrUpdateAttributeInfo(attributeEvent);
});
});
// Start the engines
- if (globalEngine != null) {
- globalEngine.start();
- }
- realmEngines.values().forEach(RulesEngine::start);
- assetEngines.values().forEach(RulesEngine::start);
- synchronized (preInitAttributeEvents) {
+ synchronized (ENGINE_LOCK) {
+ RulesEngine<?> globalRulesEngine = globalEngine.get();
+ if (globalRulesEngine != null) {
+ globalRulesEngine.start();
+ }
+
+ realmEngines.values().forEach(RulesEngine::start);
+ assetEngines.values().forEach(RulesEngine::start);
+
startDone = true;
+ preInitAttributeEvents.forEach(this::doProcessAttributeUpdate);
+ preInitAttributeEvents.clear();
}
-
- preInitAttributeEvents.forEach(this::doProcessAttributeUpdate);
- preInitAttributeEvents.clear();
}
@Override
@@ -374,14 +371,13 @@ public class RulesService extends RouteBuilder implements ContainerService {
realmEngines.forEach((realm, rulesEngine) -> rulesEngine.stop());
realmEngines.clear();
- if (globalEngine != null) {
- globalEngine.stop();
- globalEngine = null;
+ RulesEngine<?> globalRulesEngine = globalEngine.get();
+ if (globalRulesEngine != null) {
+ globalRulesEngine.stop();
+ globalEngine.set(null);
}
- synchronized (attributeEvents) {
- attributeEvents.clear();
- }
+ attributeEvents.clear();
for (GeofenceAssetAdapter geofenceAssetAdapter : geofenceAssetAdapters) {
geofenceAssetAdapter.stop(container);
@@ -401,49 +397,27 @@ public class RulesService extends RouteBuilder implements ContainerService {
* React to events that have been committed to the DB and inject them into the appropriate {@link RulesEngine}s.
*/
public void onAttributeEvent(AttributeEvent event) throws AssetProcessingException {
- synchronized (preInitAttributeEvents) {
- if (!startDone) {
- preInitAttributeEvents.add(event);
- } else {
- doProcessAttributeUpdate(event);
- }
+ if (!startDone) {
+ preInitAttributeEvents.add(event);
+ } else {
+ doProcessAttributeUpdate(event);
}
}
protected void doProcessAttributeUpdate(AttributeEvent attributeEvent) {
- // We might process two facts for a single attribute update, if that is what the user wants
-
- // First as attribute event
- retractAttributeEvent(attributeEvent);
if (isRuleState(attributeEvent) && !attributeEvent.isDeleted()) {
- updateAttributeEvent(attributeEvent);
- }
-
- // Then as rule event
- removeAttributeEvents(attributeEvent);
- if (attributeEvent.getMetaValue(MetaItemType.RULE_EVENT).orElse(false)) {
- if (!attributeEvent.isDeleted()) {
- long expireMillis = attributeEvent.getMetaValue(MetaItemType.RULE_EVENT_EXPIRES).map(expires -> {
- long expMillis = defaultEventExpiresMillis;
-
- try {
- expMillis = TimeUtil.parseTimeDuration(expires);
- } catch (RuntimeException exception) {
- LOG.log(Level.WARNING, "Failed to parse '" + MetaItemType.RULE_EVENT_EXPIRES.getName() + "' value '" + expires + "' for attribute: " + attributeEvent, exception);
- }
- return expMillis;
- }).orElse(defaultEventExpiresMillis);
-
- insertAttributeEvent(attributeEvent, expireMillis);
- }
+ insertOrUpdateAttributeInfo(attributeEvent);
+ } else {
+ retractAttributeInfo(attributeEvent);
}
}
public boolean isRulesetKnown(Ruleset ruleset) {
if (ruleset instanceof GlobalRuleset) {
- return globalEngine != null
- && globalEngine.deployments.containsKey(ruleset.getId())
- && globalEngine.deployments.get(ruleset.getId()).ruleset.getRules().equals(ruleset.getRules());
+ RulesEngine<?> globalRulesEngine = globalEngine.get();
+ return globalRulesEngine != null
+ && globalRulesEngine.deployments.containsKey(ruleset.getId())
+ && globalRulesEngine.deployments.get(ruleset.getId()).ruleset.getRules().equals(ruleset.getRules());
}
if (ruleset instanceof RealmRuleset realmRuleset) {
return realmEngines.get(realmRuleset.getRealm()) != null
@@ -537,41 +511,12 @@ public class RulesService extends RouteBuilder implements ContainerService {
return false;
});
case UPDATE -> {
- boolean attributesChanged = persistenceEvent.hasPropertyChanged("attributes");
-
- // Attribute changes will be published to the client event bus - if anything else has changed then we need to reload
- if (!attributesChanged) {
-
- }
- AttributeMap oldAttributes = attributesChanged ? ((AttributeMap) persistenceEvent.getPreviousState("attributes")) : asset.getAttributes();
- AttributeMap currentAttributes = asset.getAttributes();
-
- List<Attribute<?>> oldStateAttributes = oldAttributes
- .stream()
- .filter(RulesService::isRuleState).toList();
-
- List<Attribute<?>> newStateAttributes = currentAttributes
- .stream()
- .filter(RulesService::isRuleState).toList();
-//
-// // Just retract all old attributes rather than compare every value that might cause asset state to mutate
-// oldStateAttributes.forEach(attribute -> {
-// AttributeEvent attributeEvent = new AttributeEvent(asset.getId(), attribute.getName(), null);
-// LOG.finest("Asset was persisted (" + persistenceEvent.getCause() + "), retracting obsolete fact: " + attributeEvent);
-// retractAttributeEvent(attributeEvent);
-// });
-//
-// // Insert new states for new or changed attributes
-// newStateAttributes.forEach(attribute -> {
-// AttributeEvent attributeEvent = new AttributeEvent(asset, attribute, null, attribute.getValue().orElse(null), attribute.getTimestamp().orElse(0L));
-// LOG.finest("Asset was persisted (" + persistenceEvent.getCause() + "), inserting fact: " + attributeEvent);
-// updateAttributeEvent(attributeEvent);
-// });
+ // Attribute events are also published for updated/new attributes so nothing to do here
}
}
}
- protected synchronized void processRulesetChange(Ruleset ruleset, PersistenceEvent.Cause cause) {
+ protected void processRulesetChange(Ruleset ruleset, PersistenceEvent.Cause cause) {
if (cause == PersistenceEvent.Cause.DELETE || !ruleset.isEnabled()) {
if (ruleset instanceof GlobalRuleset) {
undeployGlobalRuleset((GlobalRuleset) ruleset);
@@ -583,49 +528,19 @@ public class RulesService extends RouteBuilder implements ContainerService {
} else {
if (ruleset instanceof GlobalRuleset) {
- boolean isNewEngine = globalEngine == null;
RulesEngine<GlobalRuleset> engine = deployGlobalRuleset((GlobalRuleset) ruleset);
-
- if (isNewEngine) {
- synchronized (attributeEvents) {
- // Push all existing facts into the engine
- attributeEvents.forEach(assetState -> engine.updateOrInsertAttributeInfo(assetState, true));
- }
- }
-
engine.start();
} else if (ruleset instanceof RealmRuleset) {
- boolean isNewEngine = !realmEngines.containsKey(((RealmRuleset) ruleset).getRealm());
RulesEngine<RealmRuleset> engine = deployRealmRuleset((RealmRuleset) ruleset);
-
- if (isNewEngine) {
- // Push all existing facts into the engine
- synchronized (attributeEvents) {
- attributeEvents.forEach(assetState -> {
- if (assetState.getRealm().equals(((RealmRuleset) ruleset).getRealm())) {
- engine.updateOrInsertAttributeInfo(assetState, true);
- }
- });
- }
- }
-
engine.start();
} else if (ruleset instanceof AssetRuleset) {
// Must reload from the database, the ruleset might not be completely hydrated on CREATE or UPDATE
AssetRuleset assetRuleset = rulesetStorageService.find(AssetRuleset.class, ruleset.getId());
- boolean isNewEngine = !assetEngines.containsKey(((AssetRuleset) ruleset).getAssetId());
RulesEngine<AssetRuleset> engine = deployAssetRuleset(assetRuleset);
-
- if (isNewEngine) {
- // Push all existing facts for this asset (and it's children into the engine)
- getAssetStatesInScope(((AssetRuleset) ruleset).getAssetId())
- .forEach(assetState -> engine.updateOrInsertAttributeInfo(assetState, true));
- }
-
engine.start();
}
}
@@ -635,15 +550,18 @@ public class RulesService extends RouteBuilder implements ContainerService {
* Deploy the ruleset into the global engine creating the engine if necessary.
*/
protected RulesEngine<GlobalRuleset> deployGlobalRuleset(GlobalRuleset ruleset) {
+ synchronized (ENGINE_LOCK) {
+ RulesEngine<GlobalRuleset> engine = globalEngine.get();
+ boolean isNewEngine = engine == null;
- synchronized (this) {
// Global rules have access to everything in the system
- if (globalEngine == null) {
- globalEngine = new RulesEngine<>(
+ if (isNewEngine) {
+ engine = new RulesEngine<>(
timerService,
this,
identityService,
executorService,
+ scheduledExecutorService,
assetStorageService,
assetProcessingService,
notificationService,
@@ -654,65 +572,87 @@ public class RulesService extends RouteBuilder implements ContainerService {
assetPredictedDatapointService,
new RulesEngineId<>(),
locationPredicateRulesConsumer,
- meterRegistry
+ rulesFiringTimer
);
+ globalEngine.set(engine);
}
- }
- globalEngine.addRuleset(ruleset);
+ if (isNewEngine) {
+ // Push all existing facts into the engine
+ RulesEngine<GlobalRuleset> finalEngine = engine;
+ attributeEvents.forEach(assetState -> finalEngine.insertOrUpdateAttributeInfo(assetState, true));
+ }
- return globalEngine;
+ engine.addRuleset(ruleset);
+ return engine;
+ }
}
- protected synchronized void undeployGlobalRuleset(GlobalRuleset ruleset) {
- if (globalEngine == null) {
- return;
- }
+ protected void undeployGlobalRuleset(GlobalRuleset ruleset) {
+ synchronized (ENGINE_LOCK) {
+ RulesEngine<GlobalRuleset> engine = globalEngine.get();
+
+ if (engine == null) {
+ return;
+ }
- if (globalEngine.removeRuleset(ruleset)) {
- globalEngine = null;
+ if (engine.removeRuleset(ruleset)) {
+ globalEngine.set(null);
+ }
}
}
protected RulesEngine<RealmRuleset> deployRealmRuleset(RealmRuleset ruleset) {
- RulesEngine<RealmRuleset> realmRulesEngine;
-
- synchronized (this) {
- // Look for existing rules engines for this realm
- realmRulesEngine = realmEngines
- .computeIfAbsent(ruleset.getRealm(), (realm) ->
- new RulesEngine<>(
- timerService,
- this,
- identityService,
- executorService,
- assetStorageService,
- assetProcessingService,
- notificationService,
- webhookService,
- alarmService,
- clientEventService,
- assetDatapointService,
- assetPredictedDatapointService,
- new RulesEngineId<>(realm),
- locationPredicateRulesConsumer,
- meterRegistry
- ));
- }
+ synchronized (ENGINE_LOCK) {
+ RulesEngine<RealmRuleset> realmRulesEngine = realmEngines.get(ruleset.getRealm());
+ boolean isNewEngine = realmRulesEngine == null;
+
+ if (isNewEngine) {
+ realmRulesEngine = new RulesEngine<>(
+ timerService,
+ this,
+ identityService,
+ executorService,
+ scheduledExecutorService,
+ assetStorageService,
+ assetProcessingService,
+ notificationService,
+ webhookService,
+ alarmService,
+ clientEventService,
+ assetDatapointService,
+ assetPredictedDatapointService,
+ new RulesEngineId<>(ruleset.getRealm()),
+ locationPredicateRulesConsumer,
+ rulesFiringTimer
+ );
+ realmEngines.put(ruleset.getRealm(), realmRulesEngine);
- realmRulesEngine.addRuleset(ruleset);
+ // Push all existing facts into the engine
+ RulesEngine<RealmRuleset> finalRealmRulesEngine = realmRulesEngine;
+ attributeEvents.forEach(assetState -> {
+ if (assetState.getRealm().equals(ruleset.getRealm())) {
+ finalRealmRulesEngine.insertOrUpdateAttributeInfo(assetState, true);
+ }
+ });
+ }
- return realmRulesEngine;
+ realmRulesEngine.addRuleset(ruleset);
+ return realmRulesEngine;
+ }
}
- protected synchronized void undeployRealmRuleset(RealmRuleset ruleset) {
- RulesEngine<RealmRuleset> rulesEngine = realmEngines.get(ruleset.getRealm());
- if (rulesEngine == null) {
- return;
- }
+ protected void undeployRealmRuleset(RealmRuleset ruleset) {
+ synchronized (ENGINE_LOCK) {
+ RulesEngine<RealmRuleset> realmRulesEngine = realmEngines.get(ruleset.getRealm());
+
+ if (realmRulesEngine == null) {
+ return;
+ }
- if (rulesEngine.removeRuleset(ruleset)) {
- realmEngines.remove(ruleset.getRealm());
+ if (realmRulesEngine.removeRuleset(ruleset)) {
+ realmEngines.remove(ruleset.getRealm());
+ }
}
}
@@ -745,122 +685,105 @@ public class RulesService extends RouteBuilder implements ContainerService {
}
protected RulesEngine<AssetRuleset> deployAssetRuleset(AssetRuleset ruleset) {
- RulesEngine<AssetRuleset> assetRulesEngine;
-
- synchronized (this) {
- // Look for existing rules engine for this asset
- assetRulesEngine = assetEngines
- .computeIfAbsent(ruleset.getAssetId(), (assetId) ->
- new RulesEngine<>(
- timerService,
- this,
- identityService,
- executorService,
- assetStorageService,
- assetProcessingService,
- notificationService,
- webhookService,
- alarmService,
- clientEventService,
- assetDatapointService,
- assetPredictedDatapointService,
- new RulesEngineId<>(ruleset.getRealm(), assetId),
- locationPredicateRulesConsumer,
- meterRegistry
- ));
- }
+ synchronized (ENGINE_LOCK) {
+ RulesEngine<AssetRuleset> assetRulesEngine = assetEngines.get(ruleset.getAssetId());
+ boolean isNewEngine = assetRulesEngine == null;
- assetRulesEngine.addRuleset(ruleset);
- return assetRulesEngine;
- }
+ if (isNewEngine) {
+ assetRulesEngine = new RulesEngine<>(
+ timerService,
+ this,
+ identityService,
+ executorService,
+ scheduledExecutorService,
+ assetStorageService,
+ assetProcessingService,
+ notificationService,
+ webhookService,
+ alarmService,
+ clientEventService,
+ assetDatapointService,
+ assetPredictedDatapointService,
+ new RulesEngineId<>(ruleset.getRealm(), ruleset.getAssetId()),
+ locationPredicateRulesConsumer,
+ rulesFiringTimer
+ );
+ assetEngines.put(ruleset.getAssetId(), assetRulesEngine);
- protected synchronized void undeployAssetRuleset(AssetRuleset ruleset) {
- RulesEngine<AssetRuleset> rulesEngine = assetEngines.get(ruleset.getAssetId());
- if (rulesEngine == null) {
- return;
- }
+ // Push all existing facts for this asset (and it's children into the engine)
+ RulesEngine<AssetRuleset> finalAssetRulesEngine = assetRulesEngine;
+ getAssetStatesInScope(ruleset.getAssetId())
+ .forEach(assetState -> finalAssetRulesEngine.insertOrUpdateAttributeInfo(assetState, true));
+ }
- if (rulesEngine.removeRuleset(ruleset)) {
- assetEngines.remove(ruleset.getAssetId());
+ assetRulesEngine.addRuleset(ruleset);
+ return assetRulesEngine;
}
}
- protected void insertAttributeEvent(AttributeInfo event, long expiresMillis) {
- // Get the chain of rule engines that we need to pass through
- List<RulesEngine<?>> rulesEngines = getEnginesInScope(event.getRealm(), event.getPath());
+ protected void undeployAssetRuleset(AssetRuleset ruleset) {
+ synchronized (ENGINE_LOCK) {
+ RulesEngine<AssetRuleset> rulesEngine = assetEngines.get(ruleset.getAssetId());
+ if (rulesEngine == null) {
+ return;
+ }
- // Pass through each engine
- for (RulesEngine<?> rulesEngine : rulesEngines) {
- rulesEngine.insertAttributeEvent(expiresMillis, event);
+ if (rulesEngine.removeRuleset(ruleset)) {
+ assetEngines.remove(ruleset.getAssetId());
+ }
}
}
- protected void removeAttributeEvents(AttributeInfo event) {
- // Get the chain of rule engines that we need to pass through
- List<RulesEngine<?>> rulesEngines = getEnginesInScope(event.getRealm(), event.getPath());
-
- // Remove all from each engine
- for (RulesEngine<?> rulesEngine : rulesEngines) {
- rulesEngine.removeAttributeEvents(event.getRef());
+ protected void insertOrUpdateAttributeInfo(AttributeEvent attributeEvent) {
+ if (attributeEvent.isOutdated()) {
+ // Attribute event is old so ignore
+ return;
}
- }
- protected void updateAttributeEvent(AttributeEvent attributeEvent) {
- LOG.finest("Updating attribute event: " + attributeEvent);
-
- synchronized (attributeEvents) {
- boolean isNewer = attributeEvents.stream().filter(event -> event.getRef().equals(attributeEvent.getRef())).findFirst()
- .map(existingEvent -> existingEvent.getTimestamp() < attributeEvent.getTimestamp()).orElse(true);
-
- if (!isNewer) {
- // Attribute event is older than the state already loaded
- return;
- }
+ LOG.log(FINEST, () -> "Inserting attribute event: " + attributeEvent);
- // Get the chain of rule engines that we need to pass through
- List<RulesEngine<?>> rulesEngines = getEnginesInScope(attributeEvent.getRealm(), attributeEvent.getPath());
+ // Remove asset state with same attribute ref as new state, add new state
+ boolean inserted = !attributeEvents.remove(attributeEvent);
+ attributeEvents.add(attributeEvent);
- // Remove asset state with same attribute ref as new state, add new state
- boolean inserted = !attributeEvents.remove(attributeEvent);
- attributeEvents.add(attributeEvent);
+ // Get the chain of rule engines that we need to pass through
+ List<RulesEngine<?>> rulesEngines = getEnginesInScope(attributeEvent.getRealm(), attributeEvent.getPath());
- // Pass through each rules engine
- for (RulesEngine<?> rulesEngine : rulesEngines) {
- rulesEngine.updateOrInsertAttributeInfo(attributeEvent, inserted);
- }
+ // Pass through each rules engine
+ for (RulesEngine<?> rulesEngine : rulesEngines) {
+ rulesEngine.insertOrUpdateAttributeInfo(attributeEvent, inserted);
}
}
- protected void retractAttributeEvent(AttributeEvent attributeEvent) {
+ protected void retractAttributeInfo(AttributeEvent attributeEvent) {
+ LOG.log(FINEST, () -> "Retracting attribute event: " + attributeEvent);
+
+ // Remove asset state with same attribute ref
+ attributeEvents.remove(attributeEvent);
+
// Get the chain of rule engines that we need to pass through
List<RulesEngine<?>> rulesEngines = getEnginesInScope(attributeEvent.getRealm(), attributeEvent.getPath());
- synchronized (attributeEvents) {
- // Remove asset state with same attribute ref
- attributeEvents.remove(attributeEvent);
-
- // Pass through each rules engine
- for (RulesEngine<?> rulesEngine : rulesEngines) {
- rulesEngine.removeAttributeInfo(attributeEvent);
- }
+ // Pass through each rules engine
+ for (RulesEngine<?> rulesEngine : rulesEngines) {
+ rulesEngine.retractAttributeInfo(attributeEvent);
}
}
protected List<AttributeInfo> getAssetStatesInScope(String assetId) {
- synchronized (attributeEvents) {
- return attributeEvents
- .stream()
- .filter(assetState -> Arrays.asList(assetState.getPath()).contains(assetId))
- .collect(Collectors.toList());
- }
+ return attributeEvents
+ .stream()
+ .filter(assetState -> Arrays.asList(assetState.getPath()).contains(assetId))
+ .collect(Collectors.toList());
}
protected List<RulesEngine<?>> getEnginesInScope(String realm, String[] assetPath) {
List<RulesEngine<?>> rulesEngines = new ArrayList<>();
// Add global engine (if it exists)
- if (globalEngine != null) {
- rulesEngines.add(globalEngine);
+ RulesEngine<?> globalRulesEngine = globalEngine.get();
+ if (globalRulesEngine != null) {
+ rulesEngines.add(globalRulesEngine);
}
// Add realm engine (if it exists)
@@ -1024,9 +947,11 @@ public class RulesService extends RouteBuilder implements ContainerService {
}
protected Optional<RulesetDeployment> getRulesetDeployment(Long rulesetId) {
- if (globalEngine != null) {
- if (globalEngine.deployments.containsKey(rulesetId)) {
- return Optional.of(globalEngine.deployments.get(rulesetId));
+
+ RulesEngine<?> globalRulesEngine = globalEngine.get();
+ if (globalRulesEngine != null) {
+ if (globalRulesEngine.deployments.containsKey(rulesetId)) {
+ return Optional.of(globalRulesEngine.deployments.get(rulesetId));
}
}
@@ -1055,8 +980,10 @@ public class RulesService extends RouteBuilder implements ContainerService {
if (!assetStates.isEmpty()) {
String realm = assetStates.get(0).getRealm();
String[] assetPaths = assetStates.stream().flatMap(assetState -> Arrays.stream(assetState.getPath())).toArray(String[]::new);
- for (RulesEngine<?> rulesEngine : getEnginesInScope(realm, assetPaths)) {
- rulesEngine.scheduleFire(false);
+ synchronized (ENGINE_LOCK) {
+ for (RulesEngine<?> rulesEngine : getEnginesInScope(realm, assetPaths)) {
+ rulesEngine.scheduleFire(false);
+ }
}
}
}
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java b/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java
index 08b1fd7c6..100cf4f05 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesetDeployment.java
@@ -43,10 +43,7 @@ import org.openremote.model.util.ValueUtil;
import javax.script.*;
import java.util.*;
-import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -90,7 +87,8 @@ public class RulesetDeployment {
final protected Rules rules = new Rules();
final protected AssetStorageService assetStorageService;
final protected TimerService timerService;
- final protected ScheduledExecutorService executorService;
+ final protected ExecutorService executorService;
+ final protected ScheduledExecutorService scheduledExecutorService;
final protected Assets assetsFacade;
final protected Users usersFacade;
final protected Notifications notificationsFacade;
@@ -110,7 +108,7 @@ public class RulesetDeployment {
protected Pair<Long, Long> nextValidity;
public RulesetDeployment(Ruleset ruleset, RulesEngine<?> rulesEngine, TimerService timerService,
- AssetStorageService assetStorageService, ScheduledExecutorService executorService,
+ AssetStorageService assetStorageService, ExecutorService executorService, ScheduledExecutorService scheduledExecutorService,
Assets assetsFacade, Users usersFacade, Notifications notificationsFacade, Webhooks webhooksFacade,
Alarms alarmsFacade, HistoricDatapoints historicDatapointsFacade, PredictedDatapoints predictedDatapointsFacade) {
this.ruleset = ruleset;
@@ -118,6 +116,7 @@ public class RulesetDeployment {
this.timerService = timerService;
this.assetStorageService = assetStorageService;
this.executorService = executorService;
+ this.scheduledExecutorService = scheduledExecutorService;
this.assetsFacade = assetsFacade;
this.usersFacade = usersFacade;
this.notificationsFacade = notificationsFacade;
@@ -127,7 +126,7 @@ public class RulesetDeployment {
this.predictedDatapointsFacade = predictedDatapointsFacade;
String ruleCategory = ruleset.getClass().getSimpleName() + "-" + ruleset.getId();
- LOG = SyslogCategory.getLogger(SyslogCategory.RULES, Ruleset.class.getName() + "." + ruleCategory);
+ LOG = SyslogCategory.getLogger(SyslogCategory.RULES, RulesEngine.class.getName() + "." + ruleCategory);
}
protected void init() throws IllegalStateException {
@@ -280,7 +279,7 @@ public class RulesetDeployment {
}
protected void scheduleRuleAction(Runnable action, long delayMillis) {
- ScheduledFuture<?> future = executorService.schedule(() -> {
+ ScheduledFuture<?> future = scheduledExecutorService.schedule(() -> {
scheduledRuleActions.removeIf(Future::isDone);
action.run();
}, delayMillis, TimeUnit.MILLISECONDS);
@@ -290,7 +289,7 @@ public class RulesetDeployment {
protected boolean compileRulesJson(Ruleset ruleset) {
try {
- jsonRulesBuilder = new JsonRulesBuilder(LOG, ruleset, rulesEngine, timerService, assetStorageService, executorService, assetsFacade, usersFacade, notificationsFacade, webhooksFacade, alarmsFacade, historicDatapointsFacade, predictedDatapointsFacade, this::scheduleRuleAction);
+ jsonRulesBuilder = new JsonRulesBuilder(LOG, ruleset, rulesEngine, timerService, assetStorageService, assetsFacade, usersFacade, notificationsFacade, webhooksFacade, alarmsFacade, historicDatapointsFacade, predictedDatapointsFacade, this::scheduleRuleAction);
for (Rule rule : jsonRulesBuilder.build()) {
LOG.finest("Registering JSON rule: " + rule.getName());
diff --git a/manager/src/main/java/org/openremote/manager/rules/geofence/ORConsoleGeofenceAssetAdapter.java b/manager/src/main/java/org/openremote/manager/rules/geofence/ORConsoleGeofenceAssetAdapter.java
index 551c1c60c..7a7bd2a53 100644
--- a/manager/src/main/java/org/openremote/manager/rules/geofence/ORConsoleGeofenceAssetAdapter.java
+++ b/manager/src/main/java/org/openremote/manager/rules/geofence/ORConsoleGeofenceAssetAdapter.java
@@ -72,7 +72,7 @@ public class ORConsoleGeofenceAssetAdapter extends RouteBuilder implements Geofe
protected AssetStorageService assetStorageService;
protected GatewayService gatewayService;
protected ManagerIdentityService identityService;
- protected ScheduledExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected ConcurrentMap<String, String> consoleIdRealmMap = new ConcurrentHashMap<>();
protected ScheduledFuture<?> notifyAssetsScheduledFuture;
protected final Set<String> notifyAssets = new HashSet<>();
@@ -87,7 +87,7 @@ public class ORConsoleGeofenceAssetAdapter extends RouteBuilder implements Geofe
this.assetStorageService = container.getService(AssetStorageService.class);
this.notificationService = container.getService(NotificationService.class);
this.identityService = container.getService(ManagerIdentityService.class);
- executorService = container.getExecutorService();
+ scheduledExecutorService = container.getScheduledExecutor();
gatewayService = container.getService(GatewayService.class);
container.getService(MessageBrokerService.class).getContext().addRoutes(this);
}
@@ -183,7 +183,7 @@ public class ORConsoleGeofenceAssetAdapter extends RouteBuilder implements Geofe
if (notifierDebounce.get()) {
if (notifyAssetsScheduledFuture == null || notifyAssetsScheduledFuture.cancel(false)) {
- notifyAssetsScheduledFuture = executorService.schedule(() -> {
+ notifyAssetsScheduledFuture = scheduledExecutorService.schedule(() -> {
synchronized (notifyAssets) {
notifyAssetGeofencesChanged(notifyAssets);
notifyAssets.clear();
@@ -259,7 +259,7 @@ public class ORConsoleGeofenceAssetAdapter extends RouteBuilder implements Geofe
final Notification notification = new Notification("GeofenceRefresh", new PushNotificationMessage().setData(data), null, null, null);
notification.setTargets(subTargets);
- executorService.schedule(() -> {
+ scheduledExecutorService.schedule(() -> {
LOG.fine("Notifying consoles that geofences have changed: " + notification.getTargets());
notificationService.sendNotification(notification);
}, (long) i * NOTIFY_ASSETS_BATCH_MILLIS, TimeUnit.MILLISECONDS);
diff --git a/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java b/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java
index 4afe3549a..7bcaa00d4 100644
--- a/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java
+++ b/manager/src/main/java/org/openremote/manager/security/ManagerKeycloakIdentityProvider.java
@@ -66,6 +66,8 @@ import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import java.util.logging.Level;
@@ -103,6 +105,7 @@ public class ManagerKeycloakIdentityProvider extends KeycloakIdentityProvider im
protected Container container;
protected String frontendURI;
protected List<String> validRedirectUris;
+ protected Map<String, Realm> realmCache = new ConcurrentHashMap<>();
@Override
public void init(Container container) {
@@ -813,17 +816,21 @@ public class ManagerKeycloakIdentityProvider extends KeycloakIdentityProvider im
@Override
public Realm getRealm(String realm) {
- try {
- return ManagerIdentityProvider.getRealmFromDb(persistenceService, realm);
- } catch (Exception ex) {
- LOG.log(Level.INFO, "Failed to get realm by name: " + realm, ex);
- }
- return null;
+ // This gets hit a lot for event authorisation so caching added
+ return realmCache.computeIfAbsent(realm, (name) -> {
+ try {
+ return ManagerIdentityProvider.getRealmFromDb(persistenceService, realm);
+ } catch (Exception ex) {
+ LOG.log(Level.INFO, "Failed to get realm by name: " + realm, ex);
+ }
+ return null;
+ });
}
@Override
public void updateRealm(Realm realm) {
LOG.fine("Update realm: " + realm);
+ realmCache.remove(realm.getName());
getRealms(realmsResource -> {
if (TextUtil.isNullOrEmpty(realm.getId())) {
@@ -945,6 +952,7 @@ public class ManagerKeycloakIdentityProvider extends KeycloakIdentityProvider im
throw new NotFoundException("Realm does not exist: " + realmName);
}
+ realmCache.remove(realmName);
persistenceService.doTransaction(entityManager -> {
// Delete gateway connections
@@ -1066,7 +1074,8 @@ public class ManagerKeycloakIdentityProvider extends KeycloakIdentityProvider im
clientResource.remove();
return null;
}, () -> {
- throw new NotFoundException("Delete client failed as client not found: " + clientId);
+ // Do nothing as could have been deleted by cleanup of previous test
+ return null;
});
});
}
diff --git a/manager/src/main/java/org/openremote/manager/setup/ManagerSetup.java b/manager/src/main/java/org/openremote/manager/setup/ManagerSetup.java
index ea231572e..71baf7410 100644
--- a/manager/src/main/java/org/openremote/manager/setup/ManagerSetup.java
+++ b/manager/src/main/java/org/openremote/manager/setup/ManagerSetup.java
@@ -46,7 +46,6 @@ import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Function;
import java.util.function.Supplier;
@@ -63,7 +62,6 @@ public class ManagerSetup implements Setup {
protected Path provisionDocRoot;
final protected TimerService timerService;
- final protected ScheduledExecutorService executorService;
final protected ManagerPersistenceService persistenceService;
final protected ManagerIdentityService identityService;
final protected AssetStorageService assetStorageService;
@@ -76,7 +74,6 @@ public class ManagerSetup implements Setup {
public ManagerSetup(Container container) {
this.timerService = container.getService(TimerService.class);
- this.executorService = container.getExecutorService();
this.persistenceService = container.getService(ManagerPersistenceService.class);
this.identityService = container.getService(ManagerIdentityService.class);
this.assetStorageService = container.getService(AssetStorageService.class);
@@ -174,8 +171,7 @@ public class ManagerSetup implements Setup {
Supplier<AgentLink<?>> agentLinker) {
room.getAttributes().addOrReplace(new Attribute<>("co2Level", POSITIVE_INTEGER).addMeta(
new MetaItem<>(UNITS, Constants.units(UNITS_PART_PER_MILLION)), new MetaItem<>(LABEL, "CO2 level"),
- new MetaItem<>(RULE_STATE, true), new MetaItem<>(RULE_EVENT, true),
- new MetaItem<>(RULE_EVENT_EXPIRES, "PT45M"), new MetaItem<>(ACCESS_RESTRICTED_READ, true),
+ new MetaItem<>(RULE_STATE, true), new MetaItem<>(ACCESS_RESTRICTED_READ, true),
new MetaItem<>(READ_ONLY, true), new MetaItem<>(STORE_DATA_POINTS)));
if (shouldBeLinked) {
@@ -188,8 +184,7 @@ public class ManagerSetup implements Setup {
Supplier<AgentLink<?>> agentLinker) {
room.getAttributes()
.addOrReplace(new Attribute<>("humidity", POSITIVE_INTEGER).addMeta(new MetaItem<>(LABEL, "Humidity"),
- new MetaItem<>(RULE_STATE, true), new MetaItem<>(RULE_EVENT, true),
- new MetaItem<>(RULE_EVENT_EXPIRES, "PT45M"), new MetaItem<>(ACCESS_RESTRICTED_READ, true),
+ new MetaItem<>(RULE_STATE, true), new MetaItem<>(ACCESS_RESTRICTED_READ, true),
new MetaItem<>(READ_ONLY, true), new MetaItem<>(UNITS, Constants.units(UNITS_PERCENTAGE)),
new MetaItem<>(STORE_DATA_POINTS)));
@@ -243,8 +238,7 @@ public class ManagerSetup implements Setup {
new Attribute<>("smartSwitchMode" + switchName, TEXT).addMeta(
new MetaItem<>(LABEL, "Smart Switch mode " + switchName),
new MetaItem<>(ACCESS_RESTRICTED_READ, true), new MetaItem<>(ACCESS_RESTRICTED_WRITE, true),
- new MetaItem<>(RULE_STATE, true), new MetaItem<>(RULE_EVENT, true),
- new MetaItem<>(RULE_EVENT_EXPIRES, "PT48H")),
+ new MetaItem<>(RULE_STATE, true)),
// Time
new Attribute<>("smartSwitchBeginEnd" + switchName, TIMESTAMP).addMeta(
new MetaItem<>(LABEL, "Smart Switch begin/end cycle " + switchName),
diff --git a/manager/src/main/java/org/openremote/manager/simulator/SimulatorService.java b/manager/src/main/java/org/openremote/manager/simulator/SimulatorService.java
index 447e76a9c..b4753c88d 100644
--- a/manager/src/main/java/org/openremote/manager/simulator/SimulatorService.java
+++ b/manager/src/main/java/org/openremote/manager/simulator/SimulatorService.java
@@ -19,9 +19,7 @@
*/
package org.openremote.manager.simulator;
-import org.apache.camel.builder.RouteBuilder;
import org.openremote.agent.protocol.simulator.SimulatorProtocol;
-import org.openremote.container.message.MessageBrokerService;
import org.openremote.manager.agent.AgentService;
import org.openremote.manager.asset.AssetStorageService;
import org.openremote.manager.event.ClientEventService;
@@ -37,14 +35,11 @@ import org.openremote.model.simulator.SimulatorState;
import java.util.List;
import java.util.logging.Logger;
-import static org.openremote.manager.event.ClientEventService.CLIENT_INBOUND_QUEUE;
-import static org.openremote.manager.event.ClientEventService.getSessionKey;
-
// RT: Removed this from META-INF as RequestSimulatorState not used anywhere
/**
* Connects the client/UI to the {@link SimulatorProtocol}.
*/
-public class SimulatorService extends RouteBuilder implements ContainerService {
+public class SimulatorService implements ContainerService {
private static final Logger LOG = Logger.getLogger(SimulatorService.class.getName());
@@ -93,7 +88,7 @@ public class SimulatorService extends RouteBuilder implements ContainerService {
return false;
});
- container.getService(MessageBrokerService.class).getContext().addRoutes(this);
+ clientEventService.addSubscription(RequestSimulatorState.class, this::onRequestSimulatorState);
}
@Override
@@ -106,23 +101,15 @@ public class SimulatorService extends RouteBuilder implements ContainerService {
}
- @Override
- public void configure() throws Exception {
- from(CLIENT_INBOUND_QUEUE)
- .routeId("ClientInbound-ReadSimulatorState")
- .filter(body().isInstanceOf(RequestSimulatorState.class))
- .process(exchange -> {
- RequestSimulatorState event = exchange.getIn().getBody(RequestSimulatorState.class);
- LOG.finest("Handling from client: " + event);
-
- String sessionKey = getSessionKey(exchange);
-
- // TODO Should realm admins be able to work with simulators in their realm?
- publishSimulatorState(sessionKey, event.getAgentId());
- });
- }
+ // TODO Should realm admins be able to work with simulators in their realm?
+ protected void onRequestSimulatorState(RequestSimulatorState event) {
+ LOG.finest("Handling from client: " + event);
+ if (event.getResponseConsumer() == null) {
+ LOG.warning("Requested simulator state but no response consumer provided");
+ return;
+ }
- protected void publishSimulatorState(String sessionKey, String agentId) {
+ String agentId = event.getAgentId();
LOG.finest("Attempting to publish simulator state: Agent ID=" + agentId);
Protocol<?> protocol = agentService.getProtocolInstance(agentId);
@@ -133,12 +120,8 @@ public class SimulatorService extends RouteBuilder implements ContainerService {
}
SimulatorState simulatorState = getSimulatorState(simulatorProtocol);
-
- if (sessionKey != null) {
- clientEventService.sendToSession(sessionKey, simulatorState);
- } else {
- clientEventService.publishEvent(simulatorState);
- }
+ simulatorState.setMessageID(event.getMessageID());
+ event.getResponseConsumer().accept(simulatorState);
}
/**
diff --git a/manager/src/main/java/org/openremote/manager/syslog/SyslogService.java b/manager/src/main/java/org/openremote/manager/syslog/SyslogService.java
index a1b3afedf..c87f8141a 100644
--- a/manager/src/main/java/org/openremote/manager/syslog/SyslogService.java
+++ b/manager/src/main/java/org/openremote/manager/syslog/SyslogService.java
@@ -61,7 +61,7 @@ public class SyslogService extends Handler implements ContainerService {
public static final int OR_SYSLOG_MAX_AGE_DAYS_DEFAULT = 5;
private static final Logger LOG = Logger.getLogger(SyslogService.class.getName());
- protected ScheduledExecutorService executorService;
+ protected ScheduledExecutorService scheduledExecutorService;
protected PersistenceService persistenceService;
protected ClientEventService clientEventService;
protected SyslogConfig config;
@@ -77,7 +77,7 @@ public class SyslogService extends Handler implements ContainerService {
@Override
public void init(Container container) throws Exception {
- executorService = container.getExecutorService();
+ scheduledExecutorService = container.getScheduledExecutor();
if (container.hasService(ClientEventService.class) && container.hasService(PersistenceService.class)) {
LOG.info("Syslog service enabled");
@@ -110,7 +110,7 @@ public class SyslogService extends Handler implements ContainerService {
TimerService timerService = container.getService(TimerService.class);
// Flush batch every 3 seconds (wait 10 seconds for database (schema) to be ready in dev mode)
- flushBatchFuture = executorService.scheduleAtFixedRate(this::flushBatch, 10, 3, TimeUnit.SECONDS);
+ flushBatchFuture = scheduledExecutorService.scheduleAtFixedRate(this::flushBatch, 10, 3, TimeUnit.SECONDS);
// Clear outdated events once a day
if (config.getStoredMaxAgeMinutes() > 0) {
@@ -119,7 +119,7 @@ public class SyslogService extends Handler implements ContainerService {
timerService.getNow(),
timerService.getNow().truncatedTo(DAYS).plus(27, ChronoUnit.HOURS));
- deleteOldFuture = executorService.scheduleAtFixedRate(
+ deleteOldFuture = scheduledExecutorService.scheduleAtFixedRate(
this::purgeSyslog,
initialDelay,
Duration.ofDays(1).toMillis(), TimeUnit.MILLISECONDS
diff --git a/manager/src/main/java/org/openremote/manager/system/HealthService.java b/manager/src/main/java/org/openremote/manager/system/HealthService.java
index 7037238b4..f4e482049 100644
--- a/manager/src/main/java/org/openremote/manager/system/HealthService.java
+++ b/manager/src/main/java/org/openremote/manager/system/HealthService.java
@@ -19,16 +19,7 @@
*/
package org.openremote.manager.system;
-import io.micrometer.core.instrument.Tags;
import io.prometheus.client.exporter.HTTPServer;
-import org.apache.camel.CamelContext;
-import org.apache.camel.NamedNode;
-import org.apache.camel.Route;
-import org.apache.camel.component.micrometer.routepolicy.MicrometerRoutePolicy;
-import org.apache.camel.component.micrometer.routepolicy.MicrometerRoutePolicyFactory;
-import org.apache.camel.component.micrometer.routepolicy.MicrometerRoutePolicyNamingStrategy;
-import org.apache.camel.component.seda.SedaEndpoint;
-import org.apache.camel.spi.RoutePolicy;
import org.openremote.container.message.MessageBrokerService;
import org.openremote.container.util.MapAccess;
import org.openremote.manager.web.ManagerWebService;
@@ -41,30 +32,28 @@ import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;
-import static org.apache.camel.component.micrometer.MicrometerConstants.ROUTE_ID_TAG;
-
/**
* This service is here to initialise the discovered {@link HealthStatusProvider}s and ({@link StatusResource}
*/
public class HealthService implements ContainerService {
- /**
- * Customised {@link MicrometerRoutePolicy} to add SEDA queue metrics
- */
- protected static class SedaMicrometerRoutePolicy extends MicrometerRoutePolicy {
- @Override
- public void onInit(Route route) {
- if (route.getEndpoint() instanceof SedaEndpoint sedaEndpoint) {
- getMeterRegistry().gauge("or.camel.route.queue.size", getNamingStrategy().getTags(route), sedaEndpoint, SedaEndpoint::getCurrentQueueSize);
- }
- super.onInit(route);
- }
- }
+// /**
+// * Customised {@link MicrometerRoutePolicy} to add SEDA queue metrics
+// */
+// protected static class SedaMicrometerRoutePolicy extends MicrometerRoutePolicy {
+// @Override
+// public void onInit(Route route) {
+// if (route.getEndpoint() instanceof SedaEndpoint sedaEndpoint) {
+// getMeterRegistry().gauge("or.camel.route.queue.size", getNamingStrategy().getTags(route), sedaEndpoint, SedaEndpoint::getCurrentQueueSize);
+// }
+// super.onInit(route);
+// }
+// }
public static final System.Logger LOG = System.getLogger(HealthService.class.getName());
public static final String OR_METRICS_PORT = "OR_METRICS_PORT";
public static final int OR_METRICS_PORT_DEFAULT = 8405;
- public static final String OR_CAMEL_ROUTE_METRIC_PREFIX = "or_camel_route";
+// public static final String OR_CAMEL_ROUTE_METRIC_PREFIX = "or_camel_route";
protected List<HealthStatusProvider> healthStatusProviderList = new ArrayList<>();
protected boolean metricsEnabled;
protected HTTPServer metricsServer;
@@ -101,7 +90,7 @@ public class HealthService implements ContainerService {
// this port can be exposed to the host but not to the public
metricsServer = new HTTPServer.Builder()
.withPort(metricsPort)
- .withExecutorService(container.getExecutorService())
+ .withExecutorService(container.getExecutor())
.build();
// Alternative servlet option to run on existing undertow but would require oauth on prometheus scraper
@@ -119,63 +108,63 @@ public class HealthService implements ContainerService {
// HttpHandler handler = WebService.addServletDeployment(container, prometheusServlet, true);
// container.getService(ManagerWebService.class).getRequestHandlers().add(0, new WebService.RequestHandler("Prometheus Metrics", exchange -> exchange.getRequestPath().equals(METRICS_PATH), handler));
- // Configure camel metrics collection here as need access to the custom registry
- MicrometerRoutePolicyFactory micrometerRoutePolicyFactory = new MicrometerRoutePolicyFactory() {
- @Override
- public RoutePolicy createRoutePolicy(CamelContext camelContext, String routeId, NamedNode routeDefinition) {
- SedaMicrometerRoutePolicy answer = new SedaMicrometerRoutePolicy();
- answer.setMeterRegistry(getMeterRegistry());
- answer.setPrettyPrint(isPrettyPrint());
- answer.setDurationUnit(getDurationUnit());
- answer.setNamingStrategy(getNamingStrategy());
- return answer;
- }
- };
- micrometerRoutePolicyFactory.setNamingStrategy(new MicrometerRoutePolicyNamingStrategy() {
- @Override
- public String getName(Route route) {
- return OR_CAMEL_ROUTE_METRIC_PREFIX;
- }
-
- @Override
- public String getExchangesSucceededName(Route route) {
- return OR_CAMEL_ROUTE_METRIC_PREFIX + "_succeeded";
- }
-
- @Override
- public String getExchangesFailedName(Route route) {
- return OR_CAMEL_ROUTE_METRIC_PREFIX + "_failed";
- }
-
- @Override
- public String getExchangesTotalName(Route route) {
- return OR_CAMEL_ROUTE_METRIC_PREFIX + "_total";
- }
-
- @Override
- public String getFailuresHandledName(Route route) {
- return OR_CAMEL_ROUTE_METRIC_PREFIX + "_failed_handled";
- }
-
- @Override
- public String getExternalRedeliveriesName(Route route) {
- return OR_CAMEL_ROUTE_METRIC_PREFIX + "_redeliveries";
- }
-
- @Override
- public Tags getTags(Route route) {
- return Tags.of(
- ROUTE_ID_TAG, route.getId());
- }
-
- @Override
- public Tags getExchangeStatusTags(Route route) {
- return Tags.of(
- ROUTE_ID_TAG, route.getId());
- }
- });
- micrometerRoutePolicyFactory.setMeterRegistry(container.getMeterRegistry());
- brokerService.getContext().addRoutePolicyFactory(micrometerRoutePolicyFactory);
+// // Configure camel metrics collection here as need access to the custom registry
+// MicrometerRoutePolicyFactory micrometerRoutePolicyFactory = new MicrometerRoutePolicyFactory() {
+// @Override
+// public RoutePolicy createRoutePolicy(CamelContext camelContext, String routeId, NamedNode routeDefinition) {
+// SedaMicrometerRoutePolicy answer = new SedaMicrometerRoutePolicy();
+// answer.setMeterRegistry(getMeterRegistry());
+// answer.setPrettyPrint(isPrettyPrint());
+// answer.setDurationUnit(getDurationUnit());
+// answer.setNamingStrategy(getNamingStrategy());
+// return answer;
+// }
+// };
+// micrometerRoutePolicyFactory.setNamingStrategy(new MicrometerRoutePolicyNamingStrategy() {
+// @Override
+// public String getName(Route route) {
+// return OR_CAMEL_ROUTE_METRIC_PREFIX;
+// }
+//
+// @Override
+// public String getExchangesSucceededName(Route route) {
+// return OR_CAMEL_ROUTE_METRIC_PREFIX + "_succeeded";
+// }
+//
+// @Override
+// public String getExchangesFailedName(Route route) {
+// return OR_CAMEL_ROUTE_METRIC_PREFIX + "_failed";
+// }
+//
+// @Override
+// public String getExchangesTotalName(Route route) {
+// return OR_CAMEL_ROUTE_METRIC_PREFIX + "_total";
+// }
+//
+// @Override
+// public String getFailuresHandledName(Route route) {
+// return OR_CAMEL_ROUTE_METRIC_PREFIX + "_failed_handled";
+// }
+//
+// @Override
+// public String getExternalRedeliveriesName(Route route) {
+// return OR_CAMEL_ROUTE_METRIC_PREFIX + "_redeliveries";
+// }
+//
+// @Override
+// public Tags getTags(Route route) {
+// return Tags.of(
+// ROUTE_ID_TAG, route.getId());
+// }
+//
+// @Override
+// public Tags getExchangeStatusTags(Route route) {
+// return Tags.of(
+// ROUTE_ID_TAG, route.getId());
+// }
+// });
+// micrometerRoutePolicyFactory.setMeterRegistry(container.getMeterRegistry());
+// brokerService.getContext().addRoutePolicyFactory(micrometerRoutePolicyFactory);
} else {
LOG.log(System.Logger.Level.INFO, "Metrics collection disabled");
}
diff --git a/model/src/main/java/org/openremote/model/Constants.java b/model/src/main/java/org/openremote/model/Constants.java
index d290d6599..fcc9ccee3 100644
--- a/model/src/main/java/org/openremote/model/Constants.java
+++ b/model/src/main/java/org/openremote/model/Constants.java
@@ -47,8 +47,6 @@ public interface Constants {
String WRITE_ALARMS_ROLE = "write:alarms";
String RESTRICTED_USER_REALM_ROLE = "restricted_user";
String AUTH_CONTEXT = "AUTH_CONTEXT";
- String SESSION_TERMINATOR = "connection.sessionTerminator";
- String SESSION_KEY = "connection.sessionKey";
String SESSION_OPEN = "connection.sessionOpen";
String SESSION_CLOSE = "connection.sessionClose";
String SESSION_CLOSE_ERROR = "connection.sessionCloseError";
diff --git a/model/src/main/java/org/openremote/model/Container.java b/model/src/main/java/org/openremote/model/Container.java
index d8301d0ea..40e28aa55 100644
--- a/model/src/main/java/org/openremote/model/Container.java
+++ b/model/src/main/java/org/openremote/model/Container.java
@@ -24,6 +24,7 @@ import org.openremote.model.util.TsIgnore;
import java.util.Collection;
import java.util.Map;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
@TsIgnore
@@ -32,7 +33,7 @@ public interface Container {
String OR_DEV_MODE = "OR_DEV_MODE";
boolean OR_DEV_MODE_DEFAULT = true;
String OR_METRICS_ENABLED = "OR_METRICS_ENABLED";
- boolean OR_METRICS_ENABLED_DEFAULT = true;
+ boolean OR_METRICS_ENABLED_DEFAULT = false;
boolean isDevMode();
@@ -40,7 +41,9 @@ public interface Container {
ContainerService[] getServices();
- ScheduledExecutorService getExecutorService();
+ ScheduledExecutorService getScheduledExecutor();
+
+ ExecutorService getExecutor();
<T extends ContainerService> Collection<T> getServices(Class<T> type);
diff --git a/model/src/main/java/org/openremote/model/asset/AssetFilter.java b/model/src/main/java/org/openremote/model/asset/AssetFilter.java
index 3e5b2a006..e9c286420 100644
--- a/model/src/main/java/org/openremote/model/asset/AssetFilter.java
+++ b/model/src/main/java/org/openremote/model/asset/AssetFilter.java
@@ -48,7 +48,7 @@ public class AssetFilter<T extends SharedEvent & AssetInfo> implements EventFilt
protected List<String> attributeNames;
protected boolean publicEvents;
protected boolean restrictedEvents;
- protected boolean internal;
+ protected boolean valueChanged;
protected List<String> userAssetIds;
public AssetFilter() {
@@ -174,12 +174,13 @@ public class AssetFilter<T extends SharedEvent & AssetInfo> implements EventFilt
return this;
}
- public boolean isInternal() {
- return internal;
+ public boolean isValueChanged() {
+ return valueChanged;
}
- public void setInternal(boolean internal) {
- this.internal = internal;
+ public AssetFilter<T> setValueChanged(boolean valueChanged) {
+ this.valueChanged = valueChanged;
+ return this;
}
public List<String> getUserAssetIds() {
@@ -197,11 +198,9 @@ public class AssetFilter<T extends SharedEvent & AssetInfo> implements EventFilt
MetaItemDescriptor<?> filterAttributesBy = null;
- // Non internal subscribers of attribute events only get value updates so make sure the value has changed
- if (!internal && event instanceof AttributeEvent attributeEvent) {
- if (!attributeEvent.valueChanged()) {
- return null;
- }
+ // Only send attribute events where value has changed if requested
+ if (valueChanged && event instanceof AttributeEvent attributeEvent && !attributeEvent.valueChanged()) {
+ return null;
}
if (!TextUtil.isNullOrEmpty(realm)) {
diff --git a/model/src/main/java/org/openremote/model/asset/DeleteAssetsRequestEvent.java b/model/src/main/java/org/openremote/model/asset/DeleteAssetsRequestEvent.java
deleted file mode 100644
index 5d47a68f8..000000000
--- a/model/src/main/java/org/openremote/model/asset/DeleteAssetsRequestEvent.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright 2017, OpenRemote Inc.
- *
- * See the CONTRIBUTORS.txt file in the distribution for a
- * full listing of individual contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package org.openremote.model.asset;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import org.openremote.model.event.shared.SharedEvent;
-import org.openremote.model.query.AssetQuery;
-
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * A client sends this event to the server to delete one or more assets, expecting
- * the server to answer "soon" with an {@link DeleteAssetsResponseEvent}.
- */
-public class DeleteAssetsRequestEvent extends SharedEvent {
-
- protected List<String> assetIds;
-
- @JsonCreator
- public DeleteAssetsRequestEvent(@JsonProperty("assetIds") List<String> assetIds) {
- this.assetIds = assetIds;
- }
-
- public List<String> getAssetIds() {
- return assetIds;
- }
-
- @Override
- public String toString() {
- return getClass().getSimpleName() + "{" +
- "ids='" + Arrays.toString(assetIds.toArray()) + '\'' +
- '}';
- }
-}
diff --git a/model/src/main/java/org/openremote/model/asset/DeleteAssetsResponseEvent.java b/model/src/main/java/org/openremote/model/asset/DeleteAssetsResponseEvent.java
deleted file mode 100644
index e8f6f775f..000000000
--- a/model/src/main/java/org/openremote/model/asset/DeleteAssetsResponseEvent.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright 2017, OpenRemote Inc.
- *
- * See the CONTRIBUTORS.txt file in the distribution for a
- * full listing of individual contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package org.openremote.model.asset;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import org.openremote.model.event.shared.SharedEvent;
-
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * A client sends this event in response to a {@link DeleteAssetsRequestEvent} indicating if the delete
- * was successful.
- */
-public class DeleteAssetsResponseEvent extends SharedEvent {
-
- protected boolean deleted;
- protected List<String> assetIds;
-
- @JsonCreator
- public DeleteAssetsResponseEvent(@JsonProperty("deleted") boolean deleted, @JsonProperty("assetIds") List<String> assetIds) {
- this.deleted = deleted;
- this.assetIds = assetIds;
- }
-
- public boolean isDeleted() {
- return deleted;
- }
-
- public List<String> getAssetIds() {
- return assetIds;
- }
-
- @Override
- public String toString() {
- return getClass().getSimpleName() + "{" +
- "deleted='" + deleted + '\'' +
- "ids='" + Arrays.toString(assetIds.toArray()) + '\'' +
- '}';
- }
-}
diff --git a/model/src/main/java/org/openremote/model/asset/ReadAssetEvent.java b/model/src/main/java/org/openremote/model/asset/ReadAssetEvent.java
index 83c76fef3..af43efc5a 100644
--- a/model/src/main/java/org/openremote/model/asset/ReadAssetEvent.java
+++ b/model/src/main/java/org/openremote/model/asset/ReadAssetEvent.java
@@ -20,21 +20,28 @@
package org.openremote.model.asset;
import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.query.AssetQuery;
import org.openremote.model.util.TextUtil;
+import java.util.function.Consumer;
+
/**
* A client sends this event to the server to read the specified asset, optionally restricting which attributes
* expecting the server to answer "soon" with an {@link AssetEvent}. If the server decides that the client doesn't have
* the right permissions, or if anything else is not in order (e.g. the asset doesn't exist), the server might not react
* at all.
*/
-public class ReadAssetEvent extends SharedEvent implements HasAssetQuery {
+public class ReadAssetEvent extends SharedEvent implements HasAssetQuery, RespondableEvent {
protected String assetId;
protected AssetQuery assetQuery;
+ @JsonIgnore
+ protected Consumer<Event> responseConsumer;
@JsonCreator
public ReadAssetEvent(@JsonProperty("assetId") String assetId) {
@@ -58,6 +65,16 @@ public class ReadAssetEvent extends SharedEvent implements HasAssetQuery {
return assetQuery;
}
+ @Override
+ public Consumer<Event> getResponseConsumer() {
+ return responseConsumer;
+ }
+
+ @Override
+ public void setResponseConsumer(Consumer<Event> responseConsumer) {
+ this.responseConsumer = responseConsumer;
+ }
+
@Override
public String toString() {
return getClass().getSimpleName() + "{" +
diff --git a/model/src/main/java/org/openremote/model/asset/ReadAssetsEvent.java b/model/src/main/java/org/openremote/model/asset/ReadAssetsEvent.java
index 7d59998f4..07cf322e0 100644
--- a/model/src/main/java/org/openremote/model/asset/ReadAssetsEvent.java
+++ b/model/src/main/java/org/openremote/model/asset/ReadAssetsEvent.java
@@ -20,18 +20,24 @@
package org.openremote.model.asset;
import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
-import org.openremote.model.event.shared.EventRequestResponseWrapper;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.query.AssetQuery;
+import java.util.function.Consumer;
+
/**
* A client sends this event to the server to query assets, expecting
* the server to answer "soon" with an {@link AssetsEvent} with the results.
*/
-public class ReadAssetsEvent extends SharedEvent implements HasAssetQuery {
+public class ReadAssetsEvent extends SharedEvent implements HasAssetQuery, RespondableEvent {
protected AssetQuery assetQuery;
+ @JsonIgnore
+ protected Consumer<Event> responseConsumer;
@JsonCreator
public ReadAssetsEvent(@JsonProperty("assetQuery") AssetQuery assetQuery) {
@@ -45,6 +51,16 @@ public class ReadAssetsEvent extends SharedEvent implements HasAssetQuery {
return assetQuery;
}
+ @Override
+ public Consumer<Event> getResponseConsumer() {
+ return responseConsumer;
+ }
+
+ @Override
+ public void setResponseConsumer(Consumer<Event> responseConsumer) {
+ this.responseConsumer = responseConsumer;
+ }
+
@Override
public String toString() {
return getClass().getSimpleName() + "{" +
diff --git a/model/src/main/java/org/openremote/model/asset/ReadAttributeEvent.java b/model/src/main/java/org/openremote/model/asset/ReadAttributeEvent.java
index ad664ebcc..fbba22a03 100644
--- a/model/src/main/java/org/openremote/model/asset/ReadAttributeEvent.java
+++ b/model/src/main/java/org/openremote/model/asset/ReadAttributeEvent.java
@@ -20,22 +20,29 @@
package org.openremote.model.asset;
import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.openremote.model.attribute.AttributeEvent;
import org.openremote.model.attribute.AttributeRef;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.SharedEvent;
import org.openremote.model.query.AssetQuery;
import org.openremote.model.util.TextUtil;
+import java.util.function.Consumer;
+
/**
* A client sends this event to the server to refresh the value of the specified attribute, expecting the server to
* answer "soon" with an {@link AttributeEvent}. If the server decides that the client doesn't have the right
* permissions, or if anything else is not in order (e.g. the asset doesn't exist), the server might not react at all.
*/
-public class ReadAttributeEvent extends SharedEvent implements HasAssetQuery {
+public class ReadAttributeEvent extends SharedEvent implements HasAssetQuery, RespondableEvent {
protected AttributeRef ref;
protected AssetQuery assetQuery;
+ @JsonIgnore
+ protected Consumer<Event> responseConsumer;
@JsonCreator
public ReadAttributeEvent(@JsonProperty("ref") AttributeRef attributeRef) {
@@ -59,6 +66,16 @@ public class ReadAttributeEvent extends SharedEvent implements HasAssetQuery {
return assetQuery;
}
+ @Override
+ public Consumer<Event> getResponseConsumer() {
+ return responseConsumer;
+ }
+
+ @Override
+ public void setResponseConsumer(Consumer<Event> responseConsumer) {
+ this.responseConsumer = responseConsumer;
+ }
+
@Override
public String toString() {
return getClass().getSimpleName() + "{" +
diff --git a/model/src/main/java/org/openremote/model/attribute/Attribute.java b/model/src/main/java/org/openremote/model/attribute/Attribute.java
index 54be4080f..eb61b974c 100644
--- a/model/src/main/java/org/openremote/model/attribute/Attribute.java
+++ b/model/src/main/java/org/openremote/model/attribute/Attribute.java
@@ -65,8 +65,8 @@ public class Attribute<T> extends AbstractNameValueHolder<T> implements MetaHold
protected static final JavaType META_MAP_TYPE = TypeFactory.defaultInstance().constructType(MetaMap.class);
protected static final JavaType OBJECT_TYPE = TypeFactory.defaultInstance().constructType(Object.class);
-
public static final System.Logger LOG = System.getLogger(AttributeDeserializer.class.getName() + "." + SyslogCategory.MODEL_AND_VALUES);
+ protected static JsonDeserializer<Object> metaDeserialiser = null;
protected AttributeDeserializer() {
super(Attribute.class);
@@ -118,8 +118,11 @@ public class Attribute<T> extends AbstractNameValueHolder<T> implements MetaHold
}
}
case "meta" -> {
- JsonDeserializer<Object> metaDeserializer = ctxt.findNonContextualValueDeserializer(META_MAP_TYPE);
- attribute.meta = (MetaMap) metaDeserializer.deserialize(jp, ctxt);
+ // findNonContextualValueDeserializer is slow so caching the result to speed up deserialisation
+ if (metaDeserialiser == null) {
+ metaDeserialiser = ctxt.findNonContextualValueDeserializer(META_MAP_TYPE);
+ }
+ attribute.meta = (MetaMap) metaDeserialiser.deserialize(jp, ctxt);
}
case "name" -> {
String name = jp.getValueAsString();
diff --git a/model/src/main/java/org/openremote/model/attribute/AttributeEvent.java b/model/src/main/java/org/openremote/model/attribute/AttributeEvent.java
index 019be8113..d87c08d5d 100644
--- a/model/src/main/java/org/openremote/model/attribute/AttributeEvent.java
+++ b/model/src/main/java/org/openremote/model/attribute/AttributeEvent.java
@@ -58,7 +58,7 @@ public class AttributeEvent extends SharedEvent implements AttributeInfo {
protected Object value;
protected boolean deleted;
@JsonIgnore
- protected Object source;
+ protected String source;
protected String realm;
@JsonView(Enhanced.class)
protected String parentId;
@@ -125,7 +125,7 @@ public class AttributeEvent extends SharedEvent implements AttributeInfo {
}
}
- public AttributeEvent(AssetInfo asset, Attribute<?> attribute, Object source, Object value, Long valueTimestamp, Object oldValue, Long oldValueTimestamp) {
+ public AttributeEvent(AssetInfo asset, Attribute<?> attribute, String source, Object value, Long valueTimestamp, Object oldValue, Long oldValueTimestamp) {
this(new AttributeRef(asset.getId(), attribute.getName()),value, valueTimestamp);
this.oldValue = oldValue;
@@ -186,11 +186,11 @@ public class AttributeEvent extends SharedEvent implements AttributeInfo {
return this;
}
- public Object getSource() {
+ public String getSource() {
return source;
}
- public AttributeEvent setSource(Object source) {
+ public AttributeEvent setSource(String source) {
this.source = source;
return this;
}
diff --git a/model/src/main/java/org/openremote/model/attribute/AttributeWriteFailure.java b/model/src/main/java/org/openremote/model/attribute/AttributeWriteFailure.java
index ecbd2b474..6d2f517f2 100644
--- a/model/src/main/java/org/openremote/model/attribute/AttributeWriteFailure.java
+++ b/model/src/main/java/org/openremote/model/attribute/AttributeWriteFailure.java
@@ -65,5 +65,15 @@ public enum AttributeWriteFailure {
/**
* Fallback failure when no other value makes sense.
*/
- UNKNOWN
+ UNKNOWN,
+
+ /**
+ * Asset ID is missing
+ */
+ ASSET_ID_MISSING,
+
+ /**
+ * Attribute name is missing
+ */
+ ATTRIBUTE_NAME_MISSING
}
diff --git a/model/src/main/java/org/openremote/model/datapoint/ValueDatapoint.java b/model/src/main/java/org/openremote/model/datapoint/ValueDatapoint.java
index a6c62423b..8ecfd5c34 100644
--- a/model/src/main/java/org/openremote/model/datapoint/ValueDatapoint.java
+++ b/model/src/main/java/org/openremote/model/datapoint/ValueDatapoint.java
@@ -29,10 +29,7 @@ public class ValueDatapoint<T> {
protected long timestamp;
protected T value;
- protected ValueDatapoint() {
- }
-
- public ValueDatapoint(@JsonProperty("x") Date timestamp,
+ protected ValueDatapoint(@JsonProperty("x") Date timestamp,
@JsonProperty("y") T value) {
this(timestamp.getTime(), value);
}
diff --git a/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointAllQuery.java b/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointAllQuery.java
index ef640cba6..3b0fe8aea 100644
--- a/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointAllQuery.java
+++ b/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointAllQuery.java
@@ -33,8 +33,8 @@ public class AssetDatapointAllQuery extends AssetDatapointQuery {
public HashMap<Integer, Object> getSQLParameters(AttributeRef attributeRef) {
HashMap<Integer, Object> parameters = new HashMap<>();
- LocalDateTime fromTimestamp = (this.fromTime != null) ? this.fromTime : LocalDateTime.ofInstant(Instant.ofEpochMilli(this.fromTimestamp), ZoneId.systemDefault());
- LocalDateTime toTimestamp = (this.toTime != null) ? this.toTime : LocalDateTime.ofInstant(Instant.ofEpochMilli(this.toTimestamp), ZoneId.systemDefault());
+ LocalDateTime fromTimestamp = (this.fromTime != null) ? this.fromTime : Instant.ofEpochMilli(this.fromTimestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
+ LocalDateTime toTimestamp = (this.toTime != null) ? this.toTime : Instant.ofEpochMilli(this.toTimestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
parameters.put(1, attributeRef.getId());
parameters.put(2, attributeRef.getName());
parameters.put(3, fromTimestamp);
diff --git a/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointIntervalQuery.java b/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointIntervalQuery.java
index 12508993f..7fc72416f 100644
--- a/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointIntervalQuery.java
+++ b/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointIntervalQuery.java
@@ -53,8 +53,8 @@ public class AssetDatapointIntervalQuery extends AssetDatapointQuery {
@Override
public HashMap<Integer, Object> getSQLParameters(AttributeRef attributeRef) {
HashMap<Integer, Object> parameters = new HashMap<>();
- LocalDateTime fromTimestamp = (this.fromTime != null) ? this.fromTime : LocalDateTime.ofInstant(Instant.ofEpochMilli(super.fromTimestamp), ZoneId.systemDefault());
- LocalDateTime toTimestamp = (this.toTime != null) ? this.toTime : LocalDateTime.ofInstant(Instant.ofEpochMilli(super.toTimestamp), ZoneId.systemDefault());
+ LocalDateTime fromTimestamp = (this.fromTime != null) ? this.fromTime : Instant.ofEpochMilli(this.fromTimestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
+ LocalDateTime toTimestamp = (this.toTime != null) ? this.toTime : Instant.ofEpochMilli(this.toTimestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
parameters.put(1, this.interval);
parameters.put(2, attributeRef.getId());
parameters.put(3, attributeRef.getName());
diff --git a/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointLTTBQuery.java b/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointLTTBQuery.java
index 798fddcc4..d29c9f707 100644
--- a/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointLTTBQuery.java
+++ b/model/src/main/java/org/openremote/model/datapoint/query/AssetDatapointLTTBQuery.java
@@ -5,6 +5,7 @@ import org.openremote.model.attribute.AttributeRef;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
+import java.time.ZoneOffset;
import java.util.HashMap;
public final class AssetDatapointLTTBQuery extends AssetDatapointQuery {
@@ -38,8 +39,8 @@ public final class AssetDatapointLTTBQuery extends AssetDatapointQuery {
@Override
public HashMap<Integer, Object> getSQLParameters(AttributeRef attributeRef) {
- LocalDateTime fromTimestamp = (this.fromTime != null) ? this.fromTime : LocalDateTime.ofInstant(Instant.ofEpochMilli(super.fromTimestamp), ZoneId.systemDefault());
- LocalDateTime toTimestamp = (this.toTime != null) ? this.toTime : LocalDateTime.ofInstant(Instant.ofEpochMilli(super.toTimestamp), ZoneId.systemDefault());
+ LocalDateTime fromTimestamp = (this.fromTime != null) ? this.fromTime : Instant.ofEpochMilli(this.fromTimestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
+ LocalDateTime toTimestamp = (this.toTime != null) ? this.toTime : Instant.ofEpochMilli(this.toTimestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
HashMap<Integer, Object> parameters = new HashMap<>();
parameters.put(1, this.amountOfPoints);
parameters.put(2, attributeRef.getId());
diff --git a/model/src/main/java/org/openremote/model/event/Event.java b/model/src/main/java/org/openremote/model/event/Event.java
index 1e2212bd4..245172b17 100644
--- a/model/src/main/java/org/openremote/model/event/Event.java
+++ b/model/src/main/java/org/openremote/model/event/Event.java
@@ -21,12 +21,9 @@ package org.openremote.model.event;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.persistence.*;
import org.openremote.model.util.TextUtil;
-import jakarta.persistence.Column;
-import jakarta.persistence.MappedSuperclass;
-import jakarta.persistence.Temporal;
-import jakarta.persistence.TemporalType;
import java.util.Date;
/**
@@ -43,6 +40,8 @@ public abstract class Event {
@Column(name = "TIMESTAMP", updatable = false, nullable = false, columnDefinition = "TIMESTAMP WITH TIME ZONE")
@JsonIgnore
protected Date timestamp;
+ @Transient
+ protected String messageID;
protected Event(Long timestamp) {
if (timestamp != null) {
@@ -78,6 +77,14 @@ public abstract class Event {
this.timestamp = new Date(timestamp);
}
+ public String getMessageID() {
+ return messageID;
+ }
+
+ public void setMessageID(String messageID) {
+ this.messageID = messageID;
+ }
+
@Override
public String toString() {
return getClass().getSimpleName() + "{" +
diff --git a/model/src/main/java/org/openremote/model/event/RespondableEvent.java b/model/src/main/java/org/openremote/model/event/RespondableEvent.java
new file mode 100644
index 000000000..76452fb4e
--- /dev/null
+++ b/model/src/main/java/org/openremote/model/event/RespondableEvent.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2024, OpenRemote Inc.
+ *
+ * See the CONTRIBUTORS.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.openremote.model.event;
+
+import java.util.function.Consumer;
+
+/**
+ * For events that require a response, the consumers of these messages are responsible for calling the response consumer
+ */
+public interface RespondableEvent {
+ Consumer<Event> getResponseConsumer();
+
+ void setResponseConsumer(Consumer<Event> responseConsumer);
+}
diff --git a/model/src/main/java/org/openremote/model/event/shared/CancelEventSubscription.java b/model/src/main/java/org/openremote/model/event/shared/CancelEventSubscription.java
index 803c4c7ac..820eefac9 100644
--- a/model/src/main/java/org/openremote/model/event/shared/CancelEventSubscription.java
+++ b/model/src/main/java/org/openremote/model/event/shared/CancelEventSubscription.java
@@ -55,7 +55,7 @@ public class CancelEventSubscription {
}
public String getEventType() {
- return eventType;
+ return eventType == null ? "" : eventType;
}
public void setEventType(String eventType) {
@@ -63,7 +63,7 @@ public class CancelEventSubscription {
}
public String getSubscriptionId() {
- return subscriptionId;
+ return subscriptionId == null ? "" : subscriptionId;
}
@Override
diff --git a/model/src/main/java/org/openremote/model/event/shared/EventFilter.java b/model/src/main/java/org/openremote/model/event/shared/EventFilter.java
index 45cedf128..5d9ef056a 100644
--- a/model/src/main/java/org/openremote/model/event/shared/EventFilter.java
+++ b/model/src/main/java/org/openremote/model/event/shared/EventFilter.java
@@ -23,6 +23,7 @@ import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import org.openremote.model.asset.AssetFilter;
+import org.openremote.model.event.Event;
import org.openremote.model.syslog.SyslogEvent;
/**
@@ -46,7 +47,7 @@ import org.openremote.model.syslog.SyslogEvent;
)
// TODO: Provide authorisation method on this interface
@FunctionalInterface
-public interface EventFilter<E extends SharedEvent> {
+public interface EventFilter<E extends Event> {
/**
*
* @return the event or a filtered copy of it if the filter matches; do not modify the supplied event.
diff --git a/model/src/main/java/org/openremote/model/event/shared/EventRequestResponseWrapper.java b/model/src/main/java/org/openremote/model/event/shared/EventRequestResponseWrapper.java
deleted file mode 100644
index 649dac637..000000000
--- a/model/src/main/java/org/openremote/model/event/shared/EventRequestResponseWrapper.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright 2020, OpenRemote Inc.
- *
- * See the CONTRIBUTORS.txt file in the distribution for a
- * full listing of individual contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package org.openremote.model.event.shared;
-
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-/**
- * A wrapper for events that require a response that provides a message ID to allow the request and response to be
- * re-associated on the client; the message ID can be any string but should be unique enough to prevent collisions with
- * other pending request-response events from the same client.
- * <p>
- * It is up to the backend to then use this message ID on the reply and to also determine what the reply message should be.
- */
-public class EventRequestResponseWrapper<T extends SharedEvent> {
-
- public static final String MESSAGE_PREFIX = "REQUESTRESPONSE:";
-
- protected String messageId;
- protected T event;
-
- @JsonCreator
- public EventRequestResponseWrapper(@JsonProperty("messageId") String messageId, @JsonProperty("event") T event) {
- this.messageId = messageId;
- this.event = event;
- }
-
- public String getMessageId() {
- return messageId;
- }
-
- public void setMessageId(String messageId) {
- this.messageId = messageId;
- }
-
- public T getEvent() {
- return event;
- }
-
- public void setEvent(T event) {
- this.event = event;
- }
-}
diff --git a/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java b/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java
index a8faab0df..3aeafadd8 100644
--- a/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java
+++ b/model/src/main/java/org/openremote/model/event/shared/EventSubscription.java
@@ -22,17 +22,15 @@ package org.openremote.model.event.shared;
import com.fasterxml.jackson.annotation.JsonIgnore;
import org.openremote.model.event.Event;
-import java.util.function.Consumer;
-
/**
- * A client can subscribe to {@link SharedEvent}s on the server, providing the
+ * A consumer can subscribe to {@link Event}s on the server, providing the
* type of event it wants to receive as well as filter criteria to restrict the
* events to an interesting subset.
* <p>
* A subscription can optionally contain a {@link #subscriptionId} which allows a client
* to have multiple subscriptions for the same event type.
*/
-public class EventSubscription<E extends SharedEvent> {
+public class EventSubscription<E extends Event> {
public static final String SUBSCRIBE_MESSAGE_PREFIX = "SUBSCRIBE:";
public static final String SUBSCRIBED_MESSAGE_PREFIX = "SUBSCRIBED:";
@@ -43,12 +41,6 @@ public class EventSubscription<E extends SharedEvent> {
@JsonIgnore
protected boolean subscribed;
- /**
- * Optional only set when an internal subscription is made
- */
- @JsonIgnore
- protected Consumer<E> internalConsumer;
-
protected EventSubscription() {
}
@@ -60,19 +52,14 @@ public class EventSubscription<E extends SharedEvent> {
this(Event.getEventType(eventClass));
}
- public EventSubscription(Class<E> eventClass, EventFilter<E> filter) {
- this(Event.getEventType(eventClass), filter);
- }
-
public EventSubscription(String eventType, EventFilter<E> filter) {
this.eventType = eventType;
this.filter = filter;
}
- public EventSubscription(Class<E> eventClass, EventFilter<E> filter, Consumer<E> internalConsumer) {
+ public EventSubscription(Class<E> eventClass, EventFilter<E> filter) {
this.eventType = Event.getEventType(eventClass);
this.filter = filter;
- this.internalConsumer = internalConsumer;
}
public EventSubscription(Class<E> eventClass, EventFilter<E> filter, String subscriptionId) {
@@ -81,19 +68,8 @@ public class EventSubscription<E extends SharedEvent> {
this.subscriptionId = subscriptionId;
}
- public EventSubscription(Class<E> eventClass, EventFilter<E> filter, String subscriptionId, Consumer<E> internalConsumer) {
- this.eventType = Event.getEventType(eventClass);
- this.filter = filter;
- this.subscriptionId = subscriptionId;
- this.internalConsumer = internalConsumer;
- }
-
public String getEventType() {
- return eventType;
- }
-
- public void setEventType(String eventType) {
- this.eventType = eventType;
+ return eventType == null ? "" : eventType;
}
public EventFilter<E> getFilter() {
@@ -108,20 +84,8 @@ public class EventSubscription<E extends SharedEvent> {
return Event.getEventType(eventClass).equals(getEventType());
}
- public Consumer<E> getInternalConsumer() {
- return internalConsumer;
- }
-
- public void setInternalConsumer(Consumer<E> internalConsumer) {
- this.internalConsumer = internalConsumer;
- }
-
- public boolean isInternal() {
- return internalConsumer != null;
- }
-
public String getSubscriptionId() {
- return subscriptionId;
+ return subscriptionId == null ? "" : subscriptionId;
}
public void setSubscribed(boolean subscribed) {
diff --git a/model/src/main/java/org/openremote/model/event/shared/SharedEvent.java b/model/src/main/java/org/openremote/model/event/shared/SharedEvent.java
index b88765678..c35a57f0f 100644
--- a/model/src/main/java/org/openremote/model/event/shared/SharedEvent.java
+++ b/model/src/main/java/org/openremote/model/event/shared/SharedEvent.java
@@ -56,9 +56,7 @@ import org.openremote.model.alarm.AlarmEvent;
@JsonSubTypes.Type(value = GatewayTunnelStartRequestEvent.class, name = "gateway-tunnel-start-request"),
@JsonSubTypes.Type(value = GatewayTunnelStartResponseEvent.class, name = "gateway-tunnel-start-response"),
@JsonSubTypes.Type(value = GatewayTunnelStopRequestEvent.class, name = "gateway-tunnel-stop-request"),
- @JsonSubTypes.Type(value = GatewayTunnelStopResponseEvent.class, name = "gateway-tunnel-stop-response"),
- @JsonSubTypes.Type(value = DeleteAssetsRequestEvent.class, name = "delete-assets-request"),
- @JsonSubTypes.Type(value = DeleteAssetsResponseEvent.class, name = "delete-assets-response")
+ @JsonSubTypes.Type(value = GatewayTunnelStopResponseEvent.class, name = "gateway-tunnel-stop-response")
})
@JsonTypeInfo(
use = JsonTypeInfo.Id.NAME,
diff --git a/model/src/main/java/org/openremote/model/event/shared/UnauthorizedEventSubscription.java b/model/src/main/java/org/openremote/model/event/shared/UnauthorizedEventSubscription.java
index 3ed7cc7b8..243733a00 100644
--- a/model/src/main/java/org/openremote/model/event/shared/UnauthorizedEventSubscription.java
+++ b/model/src/main/java/org/openremote/model/event/shared/UnauthorizedEventSubscription.java
@@ -19,6 +19,8 @@
*/
package org.openremote.model.event.shared;
+import org.openremote.model.event.Event;
+
/**
* The server returns this message when an {@link EventSubscription} failed.
* <p>
@@ -26,7 +28,7 @@ package org.openremote.model.event.shared;
* access rights. It might also fail if the subscription is invalid, for example, if
* a required filter is not supplied or if the filter is not valid.
*/
-public class UnauthorizedEventSubscription<E extends SharedEvent> {
+public class UnauthorizedEventSubscription<E extends Event> {
public static final String MESSAGE_PREFIX = "UNAUTHORIZED:";
diff --git a/model/src/main/java/org/openremote/model/gateway/GatewayCapabilitiesRequestEvent.java b/model/src/main/java/org/openremote/model/gateway/GatewayCapabilitiesRequestEvent.java
index 67d9e9f32..ea4f773ff 100644
--- a/model/src/main/java/org/openremote/model/gateway/GatewayCapabilitiesRequestEvent.java
+++ b/model/src/main/java/org/openremote/model/gateway/GatewayCapabilitiesRequestEvent.java
@@ -1,17 +1,23 @@
package org.openremote.model.gateway;
import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.SharedEvent;
import java.util.Date;
+import java.util.function.Consumer;
/**
* Request the gateway to return a {@link GatewayCapabilitiesResponseEvent}
*/
-public class GatewayCapabilitiesRequestEvent extends SharedEvent {
+public class GatewayCapabilitiesRequestEvent extends SharedEvent implements RespondableEvent {
public static final String TYPE = "gateway-capabilities-request";
+ @JsonIgnore
+ protected Consumer<Event> responseConsumer;
@JsonCreator
public GatewayCapabilitiesRequestEvent(@JsonProperty("timestamp") Date timestamp) {
@@ -22,4 +28,13 @@ public class GatewayCapabilitiesRequestEvent extends SharedEvent {
}
+ @Override
+ public Consumer<Event> getResponseConsumer() {
+ return responseConsumer;
+ }
+
+ @Override
+ public void setResponseConsumer(Consumer<Event> responseConsumer) {
+ this.responseConsumer = responseConsumer;
+ }
}
diff --git a/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStartRequestEvent.java b/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStartRequestEvent.java
index 8939e9bf5..fd7bfc87c 100644
--- a/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStartRequestEvent.java
+++ b/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStartRequestEvent.java
@@ -1,13 +1,20 @@
package org.openremote.model.gateway;
import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.SharedEvent;
-public class GatewayTunnelStartRequestEvent extends SharedEvent {
+import java.util.function.Consumer;
+
+public class GatewayTunnelStartRequestEvent extends SharedEvent implements RespondableEvent {
protected String sshHostname;
protected int sshPort;
protected GatewayTunnelInfo info;
+ @JsonIgnore
+ protected Consumer<Event> responseConsumer;
@JsonCreator
public GatewayTunnelStartRequestEvent(String sshHostname, int sshPort, GatewayTunnelInfo info) {
@@ -28,6 +35,16 @@ public class GatewayTunnelStartRequestEvent extends SharedEvent {
return sshPort;
}
+ @Override
+ public Consumer<Event> getResponseConsumer() {
+ return responseConsumer;
+ }
+
+ @Override
+ public void setResponseConsumer(Consumer<Event> responseConsumer) {
+ this.responseConsumer = responseConsumer;
+ }
+
@Override
public String toString() {
return GatewayTunnelStartRequestEvent.class.getSimpleName() + "{" +
diff --git a/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStopRequestEvent.java b/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStopRequestEvent.java
index 9881e6ef3..a70cbcc5b 100644
--- a/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStopRequestEvent.java
+++ b/model/src/main/java/org/openremote/model/gateway/GatewayTunnelStopRequestEvent.java
@@ -1,10 +1,17 @@
package org.openremote.model.gateway;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.SharedEvent;
-public class GatewayTunnelStopRequestEvent extends SharedEvent {
+import java.util.function.Consumer;
+
+public class GatewayTunnelStopRequestEvent extends SharedEvent implements RespondableEvent {
protected GatewayTunnelInfo info;
+ @JsonIgnore
+ protected Consumer<Event> responseConsumer;
protected GatewayTunnelStopRequestEvent() {
@@ -17,4 +24,14 @@ public class GatewayTunnelStopRequestEvent extends SharedEvent {
public GatewayTunnelInfo getInfo() {
return info;
}
+
+ @Override
+ public Consumer<Event> getResponseConsumer() {
+ return responseConsumer;
+ }
+
+ @Override
+ public void setResponseConsumer(Consumer<Event> responseConsumer) {
+ this.responseConsumer = responseConsumer;
+ }
}
diff --git a/model/src/main/java/org/openremote/model/rules/TemporaryFact.java b/model/src/main/java/org/openremote/model/rules/TemporaryFact.java
index 8afb9884d..3b49c684a 100644
--- a/model/src/main/java/org/openremote/model/rules/TemporaryFact.java
+++ b/model/src/main/java/org/openremote/model/rules/TemporaryFact.java
@@ -43,7 +43,7 @@ public class TemporaryFact<T> extends Event {
super(timestamp);
this.expirationMilliseconds = expirationMilliseconds;
this.fact = fact;
- this.time = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
+ this.time = Instant.ofEpochMilli(timestamp).atZone(ZoneId.systemDefault()).toLocalDateTime();
this.expirationTime = time.plus(expirationMilliseconds, ChronoUnit.MILLIS);
}
diff --git a/model/src/main/java/org/openremote/model/security/Realm.java b/model/src/main/java/org/openremote/model/security/Realm.java
index a9400fd32..0421e5891 100644
--- a/model/src/main/java/org/openremote/model/security/Realm.java
+++ b/model/src/main/java/org/openremote/model/security/Realm.java
@@ -308,6 +308,11 @@ public class Realm {
);
}
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(name);
+ }
+
@Override
public String toString() {
return getClass().getSimpleName() + "{" +
diff --git a/model/src/main/java/org/openremote/model/simulator/RequestSimulatorState.java b/model/src/main/java/org/openremote/model/simulator/RequestSimulatorState.java
index 15163d707..04b5749a2 100644
--- a/model/src/main/java/org/openremote/model/simulator/RequestSimulatorState.java
+++ b/model/src/main/java/org/openremote/model/simulator/RequestSimulatorState.java
@@ -19,17 +19,24 @@
*/
package org.openremote.model.simulator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
import org.openremote.model.asset.agent.Agent;
+import org.openremote.model.event.Event;
+import org.openremote.model.event.RespondableEvent;
import org.openremote.model.event.shared.SharedEvent;
+import java.util.function.Consumer;
+
/**
* A client sends this event to the server to request {@link SimulatorState} for the specified {@link Agent} expecting
* the server to answer "soon". If the server decides that the client doesn't have the right permissions, or if anything
* else is not in order (e.g. the agent doesn't exist), the server might not react at all.
*/
-public class RequestSimulatorState extends SharedEvent {
+public class RequestSimulatorState extends SharedEvent implements RespondableEvent {
protected String agentId;
+ @JsonIgnore
+ protected Consumer<Event> responseConsumer;
public RequestSimulatorState(String agentId) {
this.agentId = agentId;
@@ -38,4 +45,15 @@ public class RequestSimulatorState extends SharedEvent {
public String getAgentId() {
return agentId;
}
+
+
+ @Override
+ public Consumer<Event> getResponseConsumer() {
+ return responseConsumer;
+ }
+
+ @Override
+ public void setResponseConsumer(Consumer<Event> responseConsumer) {
+ this.responseConsumer = responseConsumer;
+ }
}
diff --git a/model/src/main/java/org/openremote/model/util/LockByKey.java b/model/src/main/java/org/openremote/model/util/LockByKey.java
new file mode 100644
index 000000000..b0f5167e2
--- /dev/null
+++ b/model/src/main/java/org/openremote/model/util/LockByKey.java
@@ -0,0 +1,46 @@
+/*
+ * Copied from: https://github.com/eugenp/tutorials/blob/master/core-java-modules/core-java-concurrency-advanced-4/src/main/java/com/baeldung/lockbykey/LockByKey.java
+ */
+
+package org.openremote.model.util;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class LockByKey {
+
+ private static class LockWrapper {
+ private final Lock lock = new ReentrantLock();
+ private final AtomicInteger numberOfThreadsInQueue = new AtomicInteger(1);
+
+ private LockWrapper addThreadInQueue() {
+ numberOfThreadsInQueue.incrementAndGet();
+ return this;
+ }
+
+ private int removeThreadFromQueue() {
+ return numberOfThreadsInQueue.decrementAndGet();
+ }
+
+ }
+
+ private Map<String, LockWrapper> locks = new ConcurrentHashMap<>();
+
+ public void lock(String key) {
+ LockWrapper lockWrapper = locks.compute(key, (k, v) -> v == null ? new LockWrapper() : v.addThreadInQueue());
+ lockWrapper.lock.lock();
+ }
+
+ public void unlock(String key) {
+ LockWrapper lockWrapper = locks.get(key);
+ lockWrapper.lock.unlock();
+ if (lockWrapper.removeThreadFromQueue() == 0) {
+ // NB : We pass in the specific value to remove to handle the case where another thread would queue right before the removal
+ locks.remove(key, lockWrapper);
+ }
+ }
+
+}
diff --git a/model/src/main/java/org/openremote/model/value/MetaItemType.java b/model/src/main/java/org/openremote/model/value/MetaItemType.java
index 96608d0f3..7ecae9918 100644
--- a/model/src/main/java/org/openremote/model/value/MetaItemType.java
+++ b/model/src/main/java/org/openremote/model/value/MetaItemType.java
@@ -19,8 +19,6 @@
*/
package org.openremote.model.value;
-import jakarta.validation.constraints.Pattern;
-import org.openremote.model.Constants;
import org.openremote.model.asset.UserAssetLink;
import org.openremote.model.asset.agent.AgentLink;
import org.openremote.model.attribute.Attribute;
@@ -105,33 +103,12 @@ public final class MetaItemType {
/* RULE META */
- /**
- * Set maximum lifetime of {@link org.openremote.model.attribute.AttributeInfo} temporary facts in rules, for example "PT1H30M5S". The rules engine
- * will remove temporary {@link org.openremote.model.attribute.AttributeInfo} facts if they are older than this value (using event source/value
- * timestamp, not event processing time).
- * <p>
- * The default expiration for asset events can be configured with environment variable
- * <code>RULE_EVENT_EXPIRES</code>.
- */
- @Pattern(regexp = Constants.ISO8601_DURATION_REGEXP)
- public static final MetaItemDescriptor<String> RULE_EVENT_EXPIRES = new MetaItemDescriptor<>("ruleEventExpires", ValueType.TEXT);
-
- /**
- * Should attribute writes be processed by the rules engines as temporary facts. When an attribute is updated, the
- * change will be inserted as a new {@link org.openremote.model.attribute.AttributeInfo} temporary fact in rules engines. These facts expire
- * automatically after a defined time, see {@link #RULE_EVENT_EXPIRES}. If you want to match (multiple) {@link
- * org.openremote.model.attribute.AttributeInfo}s for the same attribute over time, to evaluate the change history of an attribute, add this meta
- * item.
- */
- public static final MetaItemDescriptor<Boolean> RULE_EVENT = new MetaItemDescriptor<>("ruleEvent", ValueType.BOOLEAN);
-
/**
* Can be set to false to exclude an attribute update from being processed by the rules engines as {@link
* org.openremote.model.attribute.AttributeInfo} facts, otherwise any attribute that also has an {@link #AGENT_LINK} meta item or {@link #RULE_STATE}
* is true, will be processed with a lifecycle that reflects the state of the asset attribute. Each attribute will have one
* fact at all times in rules memory. These state facts are kept in sync with asset changes: When the attribute is
- * updated, the fact will be updated (replaced). If you want evaluate the change history of an attribute, you
- * typically need to combine this with {@link #RULE_EVENT}.
+ * updated, the fact will be updated (replaced).
*/
public static final MetaItemDescriptor<Boolean> RULE_STATE = new MetaItemDescriptor<>("ruleState", ValueType.BOOLEAN);
diff --git a/profile/deploy.yml b/profile/deploy.yml
index b3493f5c8..d24e45b61 100644
--- a/profile/deploy.yml
+++ b/profile/deploy.yml
@@ -279,12 +279,14 @@ services:
# to embedded logging.properties or logging-dev.properties (if OR_DEV_MODE=true)
OR_LOGGING_CONFIG_FILE:
- # The number of threads and therefore background tasks that can be executed at the same
- # time. Used by scheduled, usually short-lived and non-blocking tasks, such as protocols
- # polling a remote service at regular interval, or the internal checks for expired client
- # subscriptions on the event bus (default depends on detected CPU cores). Also used by
- # the rules engine.
- OR_SCHEDULED_TASKS_THREADS_MAX: ${OR_SCHEDULED_TASKS_THREADS_MAX:-4}
+ # The number of threads to be used for the scheduled executor service which can be used for scheduling
+ # non-blocking, short-lived tasks in a standard way; defaults to number of CPU cores.
+ OR_SCHEDULED_EXECUTOR_THREADS:
+
+ # The number of threads (min and max) to be used for the executor service which can be used for executing
+ # tasks in a standard way; defaults to number of CPU cores and number of CPU cores x 10 respectively.
+ OR_EXECUTOR_THREADS_MIN:
+ OR_EXECUTOR_THREADS_MAX:
# The minimum number of threads that will be used to process incoming auto provisioning messages
OR_AUTO_PROVISIONING_THREADS_MIN:
diff --git a/setup/src/integration/java/org/openremote/setup/integration/ManagerTestSetup.java b/setup/src/integration/java/org/openremote/setup/integration/ManagerTestSetup.java
index fde2ec2fa..4912acecc 100644
--- a/setup/src/integration/java/org/openremote/setup/integration/ManagerTestSetup.java
+++ b/setup/src/integration/java/org/openremote/setup/integration/ManagerTestSetup.java
@@ -21,7 +21,6 @@ package org.openremote.setup.integration;
import org.openremote.agent.protocol.simulator.SimulatorAgent;
import org.openremote.agent.protocol.simulator.SimulatorAgentLink;
-import org.openremote.model.util.UniqueIdentifierGenerator;
import org.openremote.manager.setup.ManagerSetup;
import org.openremote.model.Constants;
import org.openremote.model.Container;
@@ -34,6 +33,7 @@ import org.openremote.model.attribute.AttributeRef;
import org.openremote.model.attribute.MetaItem;
import org.openremote.model.geo.GeoJSONPoint;
import org.openremote.model.security.Realm;
+import org.openremote.model.util.UniqueIdentifierGenerator;
import org.openremote.model.value.ValueConstraint;
import org.openremote.model.value.ValueType;
import org.openremote.model.value.impl.ColourRGB;
@@ -450,9 +450,7 @@ public class ManagerTestSetup extends ManagerSetup {
new Attribute<>(Asset.LOCATION, new GeoJSONPoint(5.454053, 51.446603)),
new Attribute<>("allLightsOffSwitch", BOOLEAN, true)
.addMeta(
- new MetaItem<>(LABEL, "All Lights Off Switch"),
- new MetaItem<>(RULE_EVENT, true),
- new MetaItem<>(RULE_EVENT_EXPIRES, "PT3S")
+ new MetaItem<>(LABEL, "All Lights Off Switch")
)
);
apartment2 = assetStorageService.merge(apartment2);
@@ -472,8 +470,7 @@ public class ManagerTestSetup extends ManagerSetup {
new Attribute<>("motionSensor", BOOLEAN, false)
.addMeta(
new MetaItem<>(LABEL, "Motion Sensor"),
- new MetaItem<>(RULE_STATE, true),
- new MetaItem<>(RULE_EVENT, true)
+ new MetaItem<>(RULE_STATE, true)
),
new Attribute<>("presenceDetected", BOOLEAN, false)
.addMeta(
@@ -527,8 +524,7 @@ public class ManagerTestSetup extends ManagerSetup {
new Attribute<>("motionSensor", BOOLEAN, false)
.addMeta(
new MetaItem<>(LABEL, "Motion Sensor"),
- new MetaItem<>(RULE_STATE, true),
- new MetaItem<>(RULE_EVENT, true)
+ new MetaItem<>(RULE_STATE, true)
),
new Attribute<>("presenceDetected", BOOLEAN, false)
.addMeta(
diff --git a/setup/src/integration/java/org/openremote/setup/integration/protocol/MockProtocol.java b/setup/src/integration/java/org/openremote/setup/integration/protocol/MockProtocol.java
index 06dd7b652..96ce2c288 100644
--- a/setup/src/integration/java/org/openremote/setup/integration/protocol/MockProtocol.java
+++ b/setup/src/integration/java/org/openremote/setup/integration/protocol/MockProtocol.java
@@ -119,7 +119,7 @@ public class MockProtocol extends AbstractProtocol<MockAgent, MockAgentLink> imp
@Override
public Future<Void> startAssetDiscovery(Consumer<AssetTreeNode[]> assetConsumer) {
- return container.getExecutorService().submit(() -> {
+ return container.getExecutor().submit(() -> {
// Simulate discovery init delay
Thread.sleep(2000);
diff --git a/setup/src/load1/java/org/openremote/setup/load1/ManagerSetup.java b/setup/src/load1/java/org/openremote/setup/load1/ManagerSetup.java
index ca382618a..f4b6709be 100644
--- a/setup/src/load1/java/org/openremote/setup/load1/ManagerSetup.java
+++ b/setup/src/load1/java/org/openremote/setup/load1/ManagerSetup.java
@@ -147,7 +147,7 @@ public class ManagerSetup extends org.openremote.manager.setup.ManagerSetup {
// Wait until all devices created
int waitCounter = 0;
while (createdDevices.get() < devices) {
- if (waitCounter > 180) {
+ if (waitCounter > 200) {
throw new IllegalStateException("Failed to provision all requested devices in the specified time");
}
waitCounter++;
diff --git a/setup/src/load1/resources/org/openremote/setup/load1/WeatherAssetCalculations.groovy b/setup/src/load1/resources/org/openremote/setup/load1/WeatherAssetCalculations.groovy
index ba598cf93..b3e6930ff 100644
--- a/setup/src/load1/resources/org/openremote/setup/load1/WeatherAssetCalculations.groovy
+++ b/setup/src/load1/resources/org/openremote/setup/load1/WeatherAssetCalculations.groovy
@@ -26,37 +26,50 @@ rules.add()
.when(
{ facts ->
- List<AttributeEvent> updates = []
//LOG.info("Calculations start")
+
+ Map<String, Double> lastValues = facts.get("lastValues") as Map<String, Double>
+ if (lastValues == null) {
+ lastValues = new HashMap<>()
+ }
+
// Get weather asset rainfall and/or temperature states that have changed value
- facts.matchAssetState(
+ List<AttributeEvent> updates = facts.matchAssetState(
new AssetQuery()
.types(WeatherAsset)
.attributeNames(WeatherAsset.TEMPERATURE.name, WeatherAsset.RAINFALL.name)
).collect(Collectors.groupingBy{state -> state.id})
- .forEach{id, states ->
- // See if either attribute has changed for this asset
- if (states.any {state -> !Objects.equals(state.value.orElse(null), state.oldValue.orElse(null))} && states.size() == 2) {
- def value1 = states[0].value.orElse(0) as float
- def value2 = states[1].value.orElse(0) as float
- def calculated = value1+value2
- LOG.fine("Calculated new value for '$id': $calculated")
- updates.add(new AttributeEvent(id, "calculated", calculated))
+ .entrySet().parallelStream().map {entry ->
+ if (entry.value.size() != 2) {
+ return null
}
- }
+ def value1 = entry.value[0].value.orElse(0) as double
+ def value2 = entry.value[1].value.orElse(0) as double
+ def calc = Double.valueOf(value1+value2)
+ def lastValue = lastValues.get(entry.key)
+ return !Objects.equals(lastValue, calc) ? new AttributeEvent(entry.key, "calculated", calc) : null
+ }.filter {it != null}
+ .toList()
if (!updates.isEmpty()) {
+ LOG.info("New values calculated for ${updates.size()} assets")
facts.bind("updates", updates)
+ facts.bind("lastValues", lastValues)
+ updates.forEach {lastValues.put(it.id, it.value.orElseThrow() as Double)}
+ return true
}
//LOG.info("Calculations end")
// Trigger the rule action if we have one or more changes to process
- return !updates.isEmpty()
+ return false
})
.then(
{ facts ->
def updates = facts.bound("updates") as List<AttributeEvent>
+ def lastValues = facts.bound("lastValues")
+ facts.put("lastValues", lastValues)
LOG.info("Update start")
+ assets.dispatch(updates.get(0))
updates.forEach {
assets.dispatch(it)
}
diff --git a/test/load1/deployment1/manager/logging-load.properties b/test/load1/deployment1/manager/logging-load.properties
index e1eb0670a..32e7f24be 100644
--- a/test/load1/deployment1/manager/logging-load.properties
+++ b/test/load1/deployment1/manager/logging-load.properties
@@ -30,8 +30,7 @@ java.util.logging.ConsoleHandler.formatter=org.openremote.container.util.LogForm
# The root logger category of OpenRemote
org.openremote.level=INFO
org.openremote.agent.protocol.level=FINEST
-org.openremote.manager.mqtt.UserAssetProvisioningMQTTHandler.level=FINEST
-org.openremote.manager.mqtt.MQTTBrokerService.level=FINEST
+org.openremote.manager.mqtt.level=FINEST
# Processing time logging
#org.openremote.manager.asset.AssetProcessingService.level=FINE
diff --git a/test/load1/deployment1/test-load1.yml b/test/load1/deployment1/test-load1.yml
index b93fd172a..ac58284ac 100644
--- a/test/load1/deployment1/test-load1.yml
+++ b/test/load1/deployment1/test-load1.yml
@@ -38,6 +38,7 @@ services:
LE_EMAIL: ${OR_EMAIL_FROM:-}
DOMAINNAME: ${OR_HOSTNAME:-localhost}
DOMAINNAMES: ${OR_ADDITIONAL_HOSTNAMES:-}
+ MQTT_RATE_LIMIT: ${MQTT_RATE_LIMIT:-50}
# USE A CUSTOM PROXY CONFIG - COPY FROM https://github.com/openremote/proxy/blob/main/haproxy.cfg
#HAPROXY_CONFIG: '/data/proxy/haproxy.cfg'
@@ -93,6 +94,8 @@ services:
OR_SETUP_SERVICE_USERS:
OR_SETUP_DEVICES: ${OR_SETUP_DEVICES:-10000}
OR_SETUP_DEVICES_SKIP_COUNT:
+ OR_METRICS_ENABLED: true
+ OR_EXECUTOR_THREADS_MAX:
OR_JAVA_OPTS: ${OR_JAVA_OPTS:--Xms500m -Xmx4g -XX:NativeMemoryTracking=summary -Xlog:all=warning:stdout:uptime,level,tags -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/dump.hprof}
volumes:
- manager-data:/storage
diff --git a/test/load1/run.sh b/test/load1/run.sh
index 56d889492..a4a5fbb70 100644
--- a/test/load1/run.sh
+++ b/test/load1/run.sh
@@ -10,6 +10,8 @@
#
# `DEPLOYMENT1_DO_NOTHING` (default: false) - Do not do anything with deployment1; useful when running the test multiple times to speed up deployment
# `DEPLOYMENT1_RESTART_ONLY` (default: false) - Will only restart the manager container on deployment 1 rather than the default behaviour of stack down/up
+# `DEPLOYMENT1_MQTT_RATE_LIMIT` (default: 100/s) - Will set the MQTT_RATE_LIMIT on the proxy container to limit the connection rate of MQTT devices
+# `DEPLOYMENT1_ENV` (default: unset) - Provide custom environment variables to the deployment
# `DEPLOYMENT2_THREAD_COUNT` (default: unset) - Override console user test `THREAD_COUNT` (set to `0` to skip deployment 2 test)
# `DEPLOYMENT2_DURATION` (default: unset) - Override console user test `DURATION`
# `DEPLOYMENT2_RAMP_RATE` (default: unset) - Override console user test `RAMP_RATE`
@@ -64,6 +66,10 @@ else
cd deployment1
+if [ -n "$DEPLOYMENT1_MQTT_RATE_LIMIT" ]; then
+ \$DEPLOYMENT1_ENV = "MQTT_RATE_LIMIT=$DEPLOYMENT1_MQTT_RATE_LIMIT $DEPLOYMENT1_ENV"
+fi
+
if ! [ -f .env ]; then
OR_ADMIN_PASSWORD=\$(date +%s | sha256sum | base64 | head -c 15)
echo "OR_ADMIN_PASSWORD: \$OR_ADMIN_PASSWORD"
diff --git a/test/src/logging-test.properties b/test/src/logging-test.properties
index 45ea0b518..d90612201 100644
--- a/test/src/logging-test.properties
+++ b/test/src/logging-test.properties
@@ -29,6 +29,7 @@ java.util.logging.ConsoleHandler.formatter=org.openremote.container.util.LogForm
# The root logger category of OpenRemote
org.openremote.level=FINE
+org.openremote.manager.asset.AssetStorageService.level=INFO
# Processing time logging
#org.openremote.manager.asset.AssetProcessingService.level=FINE
@@ -46,7 +47,7 @@ org.openremote.level=FINE
#org.openremote.container.web.WebService.level=INFO
# Try to get more info on AbstractNettyIOClient as we get strange intermittent test failures
-org.openremote.agent.protocol.io.level=FINEST
+org.openremote.agent.protocol.level=FINEST
# Third party overrides
org.jboss.resteasy.level=WARNING
@@ -63,7 +64,7 @@ org.apache.camel.impl.DefaultShutdownStrategy.level=SEVERE
org.jeasy.rules.level=WARNING
org.apache.activemq.audit.level=WARNING
com.icegreen.greenmail.level=FINE
-
+com.icegreen.greenmail.util.LineLoggingBuffer.level=INFO
# Set this to FINEST to log outgoing HTTP traffic
#org.apache.http.level=WARNING
#org.apache.http.client.protocol.level=SEVERE
diff --git a/test/src/test/groovy/org/openremote/test/assets/AssetDatapointQueryTest.groovy b/test/src/test/groovy/org/openremote/test/assets/AssetDatapointQueryTest.groovy
index b869c33b6..413aa9b3d 100644
--- a/test/src/test/groovy/org/openremote/test/assets/AssetDatapointQueryTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/assets/AssetDatapointQueryTest.groovy
@@ -1,6 +1,5 @@
package org.openremote.test.assets
-import org.openremote.model.util.UniqueIdentifierGenerator
import org.openremote.manager.asset.AssetStorageService
import org.openremote.manager.datapoint.AssetDatapointService
import org.openremote.manager.setup.SetupService
@@ -16,6 +15,7 @@ import org.openremote.model.datapoint.query.AssetDatapointLTTBQuery
import org.openremote.model.geo.GeoJSONPoint
import org.openremote.model.query.AssetQuery
import org.openremote.model.query.filter.RealmPredicate
+import org.openremote.model.util.UniqueIdentifierGenerator
import org.openremote.model.value.MetaItemType
import org.openremote.model.value.ValueType
import org.openremote.setup.integration.KeycloakTestSetup
@@ -24,6 +24,7 @@ import spock.lang.Specification
import spock.util.concurrent.PollingConditions
import java.time.LocalDateTime
+import java.time.ZoneId
import static java.util.concurrent.TimeUnit.HOURS
@@ -69,11 +70,11 @@ class AssetDatapointQueryTest extends Specification implements ManagerContainerT
when: "datapoints are added to the asset"
assetDatapointService.upsertValues(asset.getId(), attributeName,
[
- new ValueDatapoint<>(dateTime.minusMinutes(25).toDate(), 50d),
- new ValueDatapoint<>(dateTime.minusMinutes(20).toDate(), 40d),
- new ValueDatapoint<>(dateTime.minusMinutes(15).toDate(), 30d),
- new ValueDatapoint<>(dateTime.minusMinutes(10).toDate(), 20d),
- new ValueDatapoint<>(dateTime.minusMinutes(5).toDate(), 10d),
+ new ValueDatapoint<>(dateTime.minusMinutes(25).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 50d),
+ new ValueDatapoint<>(dateTime.minusMinutes(20).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 40d),
+ new ValueDatapoint<>(dateTime.minusMinutes(15).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 30d),
+ new ValueDatapoint<>(dateTime.minusMinutes(10).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 20d),
+ new ValueDatapoint<>(dateTime.minusMinutes(5).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 10d),
]
)
@@ -124,12 +125,12 @@ class AssetDatapointQueryTest extends Specification implements ManagerContainerT
assetDatapointService.upsertValues(asset.getId(), attributeName,
[
// placing them in a random order to verify order that is returned with the query
- new ValueDatapoint<>(dateTime.minusMinutes(10).toDate(), 25d),
- new ValueDatapoint<>(dateTime.minusMinutes(5).toDate(), 30d),
- new ValueDatapoint<>(dateTime.minusMinutes(30).toDate(), 10d),
- new ValueDatapoint<>(dateTime.minusMinutes(20).toDate(), 90d),
- new ValueDatapoint<>(dateTime.minusMinutes(25).toDate(), 15d),
- new ValueDatapoint<>(dateTime.minusMinutes(15).toDate(), 20d),
+ new ValueDatapoint<>(dateTime.minusMinutes(10).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 25d),
+ new ValueDatapoint<>(dateTime.minusMinutes(5).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 30d),
+ new ValueDatapoint<>(dateTime.minusMinutes(30).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 10d),
+ new ValueDatapoint<>(dateTime.minusMinutes(20).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 90d),
+ new ValueDatapoint<>(dateTime.minusMinutes(25).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 15d),
+ new ValueDatapoint<>(dateTime.minusMinutes(15).atZone(ZoneId.systemDefault()).toInstant().toEpochMilli(), 20d),
]
)
diff --git a/test/src/test/groovy/org/openremote/test/assets/AssetDatapointTest.groovy b/test/src/test/groovy/org/openremote/test/assets/AssetDatapointTest.groovy
index a26daecc0..917e0e4df 100644
--- a/test/src/test/groovy/org/openremote/test/assets/AssetDatapointTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/assets/AssetDatapointTest.groovy
@@ -150,8 +150,8 @@ class AssetDatapointTest extends Specification implements ManagerContainerTrait
thing.getId(),
"light1PowerConsumption",
new AssetDatapointIntervalQuery(
- LocalDateTime.ofInstant(Instant.ofEpochMilli(getClockTimeOf(container)), ZoneId.systemDefault()).minus(1, ChronoUnit.HOURS),
- LocalDateTime.ofInstant(Instant.ofEpochMilli(getClockTimeOf(container)), ZoneId.systemDefault()),
+ Instant.ofEpochMilli(getClockTimeOf(container)).atZone(ZoneId.systemDefault()).toLocalDateTime().minus(1, ChronoUnit.HOURS),
+ Instant.ofEpochMilli(getClockTimeOf(container)).atZone(ZoneId.systemDefault()).toLocalDateTime(),
"minute",
AssetDatapointIntervalQuery.Formula.AVG,
true
@@ -175,8 +175,8 @@ class AssetDatapointTest extends Specification implements ManagerContainerTrait
thing.getId(),
"light1PowerConsumption",
new AssetDatapointIntervalQuery(
- LocalDateTime.ofInstant(Instant.ofEpochMilli(getClockTimeOf(container)), ZoneId.systemDefault()).minus(1, ChronoUnit.HOURS),
- LocalDateTime.ofInstant(Instant.ofEpochMilli(getClockTimeOf(container)), ZoneId.systemDefault()),
+ Instant.ofEpochMilli(getClockTimeOf(container)).atZone(ZoneId.systemDefault()).toLocalDateTime().minus(1, ChronoUnit.HOURS),
+ Instant.ofEpochMilli(getClockTimeOf(container)).atZone(ZoneId.systemDefault()).toLocalDateTime(),
"5 minutes",
AssetDatapointIntervalQuery.Formula.AVG,
true
@@ -247,8 +247,8 @@ class AssetDatapointTest extends Specification implements ManagerContainerTrait
thing.getId(),
thingLightToggleAttributeName,
new AssetDatapointIntervalQuery(
- LocalDateTime.ofInstant(Instant.ofEpochMilli(getClockTimeOf(container)), ZoneId.systemDefault()).minus(1, ChronoUnit.HOURS),
- LocalDateTime.ofInstant(Instant.ofEpochMilli(getClockTimeOf(container)), ZoneId.systemDefault()),
+ Instant.ofEpochMilli(getClockTimeOf(container)).atZone(ZoneId.systemDefault()).toLocalDateTime().minus(1, ChronoUnit.HOURS),
+ Instant.ofEpochMilli(getClockTimeOf(container)).atZone(ZoneId.systemDefault()).toLocalDateTime(),
"MINUTE",
AssetDatapointIntervalQuery.Formula.AVG,
true
diff --git a/test/src/test/groovy/org/openremote/test/assets/AssetQueryTest.groovy b/test/src/test/groovy/org/openremote/test/assets/AssetQueryTest.groovy
index 32d2b32d0..064cfb0a6 100644
--- a/test/src/test/groovy/org/openremote/test/assets/AssetQueryTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/assets/AssetQueryTest.groovy
@@ -26,10 +26,11 @@ import spock.lang.Specification
import spock.util.concurrent.PollingConditions
import java.time.Instant
+import java.time.ZoneId
import java.time.ZoneOffset
import java.time.ZonedDateTime
-import static java.time.format.DateTimeFormatter.ISO_ZONED_DATE_TIME
+import static java.time.format.DateTimeFormatter.ISO_OFFSET_DATE_TIME
import static org.openremote.model.query.AssetQuery.*
import static org.openremote.model.query.AssetQuery.Access.PRIVATE
import static org.openremote.model.query.AssetQuery.Access.PROTECTED
@@ -922,12 +923,12 @@ class AssetQueryTest extends Specification implements ManagerContainerTrait {
when: "the lobby has an opening date and the date falls is between the filtering date"
def lobby = assetStorageService.find(managerTestSetup.lobbyId, true)
lobby.addAttributes(
- new Attribute<>("openingDate", TIMESTAMP_ISO8601, ZonedDateTime.ofInstant(Instant.ofEpochMilli(1517151600000), ZoneOffset.UTC).format(ISO_ZONED_DATE_TIME)) // 28/01/2018 @ 2:00pm (UTC)
+ new Attribute<>("openingDate", TIMESTAMP_ISO8601, Instant.ofEpochMilli(1517151600000).atZone(ZoneId.systemDefault()).format(ISO_OFFSET_DATE_TIME)) // 28/01/2018 @ 2:00pm (UTC)
)
lobby = assetStorageService.merge(lobby)
- def rangeStart = ZonedDateTime.ofInstant(Instant.ofEpochMilli(1517151600000), ZoneOffset.UTC).minusHours(2) // 28/01/2018 @ 1:00pm (UTC)
- def rangeEnd = ZonedDateTime.ofInstant(Instant.ofEpochMilli(1517151600000), ZoneOffset.UTC).plusHours(3) // 28/01/2018 @ 6:00pm (UTC)
+ def rangeStart = Instant.ofEpochMilli(1517151600000).atZone(ZoneId.systemDefault()).minusHours(2) // 28/01/2018 @ 1:00pm (UTC)
+ def rangeEnd = Instant.ofEpochMilli(1517151600000).atZone(ZoneId.systemDefault()).plusHours(3) // 28/01/2018 @ 6:00pm (UTC)
def assets = assetStorageService.findAll(
new AssetQuery()
@@ -935,7 +936,7 @@ class AssetQueryTest extends Specification implements ManagerContainerTrait {
.realm(new RealmPredicate(keycloakTestSetup.realmMaster.name))
.attributeValue(
"openingDate",
- new DateTimePredicate(rangeStart.format(ISO_ZONED_DATE_TIME), rangeEnd.format(ISO_ZONED_DATE_TIME))
+ new DateTimePredicate(rangeStart.format(ISO_OFFSET_DATE_TIME), rangeEnd.format(ISO_OFFSET_DATE_TIME))
.operator(Operator.BETWEEN))
)
@@ -951,7 +952,7 @@ class AssetQueryTest extends Specification implements ManagerContainerTrait {
.realm(new RealmPredicate(keycloakTestSetup.realmMaster.name))
.attributeValue(
"openingDate",
- new DateTimePredicate(Operator.GREATER_THAN, rangeStart.format(ISO_ZONED_DATE_TIME)))
+ new DateTimePredicate(Operator.GREATER_THAN, rangeStart.format(ISO_OFFSET_DATE_TIME)))
)
@@ -966,7 +967,7 @@ class AssetQueryTest extends Specification implements ManagerContainerTrait {
.realm(new RealmPredicate(keycloakTestSetup.realmMaster.name))
.attributeValue(
"openingDate",
- new DateTimePredicate(Operator.LESS_THAN, rangeEnd.format(ISO_ZONED_DATE_TIME)))
+ new DateTimePredicate(Operator.LESS_THAN, rangeEnd.format(ISO_OFFSET_DATE_TIME)))
)
@@ -975,7 +976,7 @@ class AssetQueryTest extends Specification implements ManagerContainerTrait {
assets[0].id == lobby.id
when: "the lobby has an opening date and the date is equal to the filtering date"
- rangeStart = ZonedDateTime.ofInstant(Instant.ofEpochMilli(1517151600000), ZoneOffset.UTC) // 28/01/2018 @ 2:00pm (UTC)
+ rangeStart = Instant.ofEpochMilli(1517151600000).atZone(ZoneId.systemDefault()) // 28/01/2018 @ 2:00pm (UTC)
assets = assetStorageService.findAll(
new AssetQuery()
@@ -983,7 +984,7 @@ class AssetQueryTest extends Specification implements ManagerContainerTrait {
.realm(new RealmPredicate(keycloakTestSetup.realmMaster.name))
.attributeValue(
"openingDate",
- new DateTimePredicate(Operator.EQUALS, rangeStart.format(ISO_ZONED_DATE_TIME)))
+ new DateTimePredicate(Operator.EQUALS, rangeStart.format(ISO_OFFSET_DATE_TIME)))
)
diff --git a/test/src/test/groovy/org/openremote/test/benchmark/AttributeEventBenchmarkTest.groovy b/test/src/test/groovy/org/openremote/test/benchmark/AttributeEventBenchmarkTest.groovy
new file mode 100644
index 000000000..05abdeea2
--- /dev/null
+++ b/test/src/test/groovy/org/openremote/test/benchmark/AttributeEventBenchmarkTest.groovy
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2024, OpenRemote Inc.
+ *
+ * See the CONTRIBUTORS.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.openremote.test.benchmark
+
+import org.openremote.agent.protocol.mqtt.MQTTMessage
+import org.openremote.agent.protocol.mqtt.MQTT_IOClient
+import org.openremote.manager.asset.AssetStorageService
+import org.openremote.manager.mqtt.DefaultMQTTHandler
+import org.openremote.manager.mqtt.MQTTBrokerService
+import org.openremote.manager.mqtt.MQTTHandler
+import org.openremote.manager.setup.SetupService
+import org.openremote.model.asset.agent.ConnectionStatus
+import org.openremote.model.asset.impl.ThingAsset
+import org.openremote.model.attribute.Attribute
+import org.openremote.model.auth.UsernamePassword
+import org.openremote.model.event.shared.SharedEvent
+import org.openremote.model.util.UniqueIdentifierGenerator
+import org.openremote.model.util.ValueUtil
+import org.openremote.model.value.ValueType
+import org.openremote.setup.integration.KeycloakTestSetup
+import org.openremote.test.ManagerContainerTrait
+import spock.lang.Ignore
+import spock.lang.Specification
+import spock.util.concurrent.PollingConditions
+
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.function.Consumer
+
+import static org.openremote.container.util.MapAccess.getInteger
+import static org.openremote.container.util.MapAccess.getString
+import static org.openremote.manager.mqtt.MQTTBrokerService.*
+
+/**
+ * This benchmark is intended to determine the throughput of AttributeEvents over MQTT which is a typical use case.
+ * In this simple scenario an MQTT client has subscribed to attributes of an asset and also publishes attribute events
+ * for this asset. The time taken for a response to arrive after a publish is a simple measure of the throughput of the
+ * system; this can be used to monitor the performance change of the system over time on a given system specification.
+ */
+
+@Ignore
+class AttributeEventBenchmarkTest extends Specification implements ManagerContainerTrait {
+
+ def "Attribute processing benchmark"() {
+
+ given: "the container environment is started"
+ def eventCount = 1000
+ def startTime = -1l
+ def endTime = -1l
+ List<SharedEvent> receivedEvents = new CopyOnWriteArrayList<>()
+ List<Object> receivedValues = new CopyOnWriteArrayList<>()
+ MQTT_IOClient client = null
+ def conditions = new PollingConditions(timeout: 15, initialDelay: 0.1, delay: 0.2)
+ def container = startContainer(defaultConfig(), defaultServices())
+ def keycloakTestSetup = container.getService(SetupService.class).getTaskOfType(KeycloakTestSetup.class)
+ def mqttBrokerService = container.getService(MQTTBrokerService.class)
+ def defaultMQTTHandler = mqttBrokerService.getCustomHandlers().find{it instanceof DefaultMQTTHandler} as DefaultMQTTHandler
+ def assetStorageService = container.getService(AssetStorageService.class)
+ def mqttClientId = UniqueIdentifierGenerator.generateId()
+ def username = keycloakTestSetup.realmBuilding.name + ":" + keycloakTestSetup.serviceUser.username // realm and OAuth client id
+ def password = keycloakTestSetup.serviceUser.secret
+ def mqttHost = getString(container.getConfig(), MQTT_SERVER_LISTEN_HOST, "0.0.0.0")
+ def mqttPort = getInteger(container.getConfig(), MQTT_SERVER_LISTEN_PORT, 1883)
+ def assetIDs = new ArrayList<String>()
+ def assetMultiID = ""
+
+ and: "assets are added for testing purposes"
+ for (i in 1..eventCount) {
+ def asset = assetStorageService.merge(new ThingAsset("TestThing$i").setRealm(keycloakTestSetup.realmBuilding.name).addAttributes(
+ new Attribute<Object>("counter", ValueType.NUMBER)
+ ))
+ assetIDs.add(asset.id)
+ }
+ and: "one asset is added with many attributes"
+ def multiAsset = new ThingAsset("TestThingMulti").setRealm(keycloakTestSetup.realmBuilding.name)
+ for (i in 1..eventCount) {
+ multiAsset.addAttributes(new Attribute<Object>("counter$i", ValueType.NUMBER))
+ }
+ multiAsset = assetStorageService.merge(multiAsset)
+ assetMultiID = multiAsset.id
+
+ when: "a mqtt client connects with valid credentials"
+ client = new MQTT_IOClient(mqttClientId, mqttHost, mqttPort, false, true, new UsernamePassword(username, password), null, null)
+ client.connect()
+
+ then: "mqtt connection should exist"
+ conditions.eventually {
+ assert client.getConnectionStatus() == ConnectionStatus.CONNECTED
+ assert mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id).size() == 1
+ }
+
+ when: "a mqtt client subscribes to all attributes of all assets"
+ def topic = "${keycloakTestSetup.realmBuilding.name}/$mqttClientId/$DefaultMQTTHandler.ATTRIBUTE_TOPIC/$MQTTHandler.TOKEN_SINGLE_LEVEL_WILDCARD/$MQTTHandler.TOKEN_MULTI_LEVEL_WILDCARD".toString()
+ Consumer<MQTTMessage<String>> eventConsumer = { msg ->
+ def event = ValueUtil.parse(msg.payload, SharedEvent.class)
+ receivedEvents.add(event.get())
+ if (receivedEvents.size() == eventCount) {
+ endTime = System.currentTimeMillis()
+ }
+ }
+ def subscribed = client.addMessageConsumer(topic, eventConsumer)
+
+ then: "A subscription should exist"
+ assert subscribed
+ assert client.topicConsumerMap.get(topic) != null
+ assert client.topicConsumerMap.get(topic).size() == 1
+ assert mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id).size() == 1
+ def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
+ assert connection != null
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
+
+ when: "Attribute events are sent for each asset by the MQTT client"
+ startTime = System.currentTimeMillis()
+ for (i in 1..eventCount) {
+ topic = "${keycloakTestSetup.realmBuilding.name}/$mqttClientId/$DefaultMQTTHandler.ATTRIBUTE_VALUE_WRITE_TOPIC/counter/${assetIDs.get(i-1)}".toString()
+ def payload = i.toString()
+ client.sendMessage(new MQTTMessage<String>(topic, payload))
+ }
+
+ then: "all attribute updates should be received by the client"
+ new PollingConditions(timeout: 300, initialDelay: 10, delay: 10).eventually {
+ getLOG().info("Events processed = ${receivedEvents.size()}")
+ assert endTime > 0
+ }
+ def processingTime = endTime-startTime
+ getLOG().info("Time taken to process $eventCount events = ${endTime-startTime}ms")
+
+ when: "Attribute events are again sent for each asset by the MQTT client"
+ endTime = 0
+ receivedEvents.clear()
+ startTime = System.currentTimeMillis()
+ for (i in 1..eventCount) {
+ topic = "${keycloakTestSetup.realmBuilding.name}/$mqttClientId/$DefaultMQTTHandler.ATTRIBUTE_VALUE_WRITE_TOPIC/counter/${assetIDs.get(i-1)}".toString()
+ def payload = i.toString()
+ client.sendMessage(new MQTTMessage<String>(topic, payload))
+ }
+
+ then: "all attribute updates should be received by the client in a shorter time due to auth caching"
+ new PollingConditions(timeout: 300, initialDelay: 10, delay: 10).eventually {
+ getLOG().info("Events processed = ${receivedEvents.size()}")
+ assert endTime > 0
+ }
+ assert processingTime > endTime-startTime
+ getLOG().info("Time taken to process $eventCount events (with hot cache) = ${endTime-startTime}ms")
+
+
+ when: "Attribute events are sent for each attribute of the multi asset by the MQTT client"
+ endTime = 0
+ receivedEvents.clear()
+ startTime = System.currentTimeMillis()
+ for (i in 1..eventCount) {
+ topic = "${keycloakTestSetup.realmBuilding.name}/$mqttClientId/$DefaultMQTTHandler.ATTRIBUTE_VALUE_WRITE_TOPIC/counter$i/${assetMultiID}".toString()
+ def payload = i.toString()
+ client.sendMessage(new MQTTMessage<String>(topic, payload))
+ }
+
+ then: "all attribute updates should be received by the client"
+ new PollingConditions(timeout: 300, initialDelay: 10, delay: 10).eventually {
+ getLOG().info("Events processed = ${receivedEvents.size()}")
+ assert endTime > 0
+ }
+ getLOG().info("Time taken to process $eventCount events for multi attribute asset = ${endTime-startTime}ms")
+
+ cleanup: "output processing time"
+ if (client != null) {
+ client.disconnect()
+ }
+ }
+}
diff --git a/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy b/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy
index 31b940eea..b4471291f 100644
--- a/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/console/ConsoleTest.groovy
@@ -110,7 +110,7 @@ class ConsoleTest extends Specification implements ManagerContainerTrait {
def realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
assert realmBuildingEngine != null
assert realmBuildingEngine.isRunning()
- assert realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert realmBuildingEngine.facts.getAssetStates().size() == DEMO_RULE_STATES_SMART_BUILDING
}
and: "an authenticated user"
diff --git a/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovy b/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovy
index 66e173581..2b7e110de 100644
--- a/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovy
@@ -13,14 +13,13 @@ import org.openremote.model.attribute.AttributeEvent
import org.openremote.model.attribute.AttributeRef
import org.openremote.model.datapoint.query.AssetDatapointIntervalQuery
import org.openremote.model.util.ValueUtil
-import org.openremote.test.ManagerContainerTrait
import org.openremote.setup.integration.ManagerTestSetup
+import org.openremote.test.ManagerContainerTrait
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
import java.time.Duration
import java.time.Instant
-import java.time.LocalDateTime
import java.time.ZoneId
import java.time.temporal.ChronoUnit
import java.util.concurrent.TimeUnit
@@ -84,7 +83,7 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
then: "the optimisation start time should be correctly calculated"
def optimiser = optimisationService.assetOptimisationInstanceMap.get(managerTestSetup.electricityOptimisationAssetId).energyOptimiser
def optimisationTime = optimisationService.getOptimisationStartTime(now.toEpochMilli(), (long)optimiser.intervalSize * 60 * 60)
- def optimisationDateTime = LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault())
+ def optimisationDateTime = optimisationTime.atZone(ZoneId.systemDefault()).toLocalDateTime()
assert optimisationTime.isBefore(now)
assert optimisationTime.plus((long)optimiser.intervalSize*60, ChronoUnit.MINUTES).equals(now)
@@ -128,8 +127,8 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
managerTestSetup.electricityBatteryAssetId,
ElectricityAsset.POWER_SETPOINT.name,
new AssetDatapointIntervalQuery(
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
(optimiser.intervalSize * 60) + " minutes",
AssetDatapointIntervalQuery.Formula.AVG,
true
@@ -160,8 +159,8 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
managerTestSetup.electricityBatteryAssetId,
ElectricityAsset.POWER_SETPOINT.name,
new AssetDatapointIntervalQuery(
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
(optimiser.intervalSize * 60) + " minutes",
AssetDatapointIntervalQuery.Formula.AVG,
true
@@ -192,8 +191,8 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
managerTestSetup.electricityBatteryAssetId,
ElectricityAsset.POWER_SETPOINT.name,
new AssetDatapointIntervalQuery(
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
(optimiser.intervalSize * 60) + " minutes",
AssetDatapointIntervalQuery.Formula.AVG,
true
@@ -255,7 +254,7 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
then: "the optimisation start time should be correctly calculated"
def optimiser = optimisationService.assetOptimisationInstanceMap.get(managerTestSetup.electricityOptimisationAssetId).energyOptimiser
def optimisationTime = optimisationService.getOptimisationStartTime(now.toEpochMilli(), (long)optimiser.intervalSize * 60 * 60)
- def optimisationDateTime = LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault())
+ def optimisationDateTime = optimisationTime.atZone(ZoneId.systemDefault())
assert optimisationTime.isBefore(now)
assert optimisationTime.plus((long)optimiser.intervalSize*60, ChronoUnit.MINUTES).equals(now)
@@ -266,8 +265,8 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
assetProcessingService.sendAttributeEvent(new AttributeEvent(managerTestSetup.electricitySolarAssetId, ElectricityAsset.POWER.name, producerPower.get(0)))
for (int i = 1; i < consumerPower.size(); i++) {
- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricityConsumerAssetId, ElectricityAsset.POWER.name), consumerPower.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))
- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySolarAssetId, ElectricityAsset.POWER.name), producerPower.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))
+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricityConsumerAssetId, ElectricityAsset.POWER.name), consumerPower.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES).toLocalDateTime())
+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySolarAssetId, ElectricityAsset.POWER.name), producerPower.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES).toLocalDateTime())
}
and: "supplier tariff values are set for the next 24hrs"
@@ -277,8 +276,8 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
assetProcessingService.sendAttributeEvent(new AttributeEvent(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_EXPORT.name, tariffExports.get(0)))
for (int i = 1; i < tariffExports.size(); i++) {
- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_IMPORT.name), tariffImports.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))
- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_EXPORT.name), tariffExports.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))
+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_IMPORT.name), tariffImports.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES).toLocalDateTime())
+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_EXPORT.name), tariffExports.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES).toLocalDateTime())
}
then: "the current values of each attribute should have reached the DB"
@@ -303,8 +302,8 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
managerTestSetup.electricityBatteryAssetId,
ElectricityAsset.POWER_SETPOINT.name,
new AssetDatapointIntervalQuery(
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
- LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
+ optimisationTime.atZone(ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES).toLocalDateTime(),
(optimiser.intervalSize * 60) + " minutes",
AssetDatapointIntervalQuery.Formula.AVG,
true
diff --git a/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy b/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy
index 5341b8c2c..160c1f303 100644
--- a/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/gateway/GatewayTest.groovy
@@ -5,7 +5,6 @@ import org.apache.http.client.utils.URIBuilder
import org.openremote.agent.protocol.http.HTTPAgent
import org.openremote.agent.protocol.http.HTTPAgentLink
import org.openremote.agent.protocol.io.AbstractNettyIOClient
-import org.openremote.agent.protocol.simulator.SimulatorProtocol
import org.openremote.agent.protocol.websocket.WebsocketIOClient
import org.openremote.container.timer.TimerService
import org.openremote.container.web.WebTargetBuilder
@@ -13,22 +12,20 @@ import org.openremote.manager.agent.AgentService
import org.openremote.manager.asset.AssetProcessingService
import org.openremote.manager.asset.AssetStorageService
import org.openremote.manager.event.ClientEventService
-import org.openremote.manager.gateway.GatewayClientService
-import org.openremote.manager.gateway.GatewayConnector
-import org.openremote.manager.gateway.GatewayService
-import org.openremote.manager.gateway.JSchGatewayTunnelFactory
+import org.openremote.manager.gateway.*
import org.openremote.manager.security.ManagerIdentityService
import org.openremote.manager.security.ManagerKeycloakIdentityProvider
import org.openremote.manager.setup.SetupService
-import org.openremote.model.asset.*
+import org.openremote.model.asset.Asset
+import org.openremote.model.asset.AssetEvent
+import org.openremote.model.asset.AssetsEvent
+import org.openremote.model.asset.ReadAssetsEvent
import org.openremote.model.asset.agent.ConnectionStatus
import org.openremote.model.asset.impl.*
import org.openremote.model.attribute.Attribute
import org.openremote.model.attribute.AttributeEvent
-import org.openremote.model.attribute.AttributeRef
import org.openremote.model.attribute.MetaItem
import org.openremote.model.auth.OAuthClientCredentialsGrant
-import org.openremote.model.event.shared.EventRequestResponseWrapper
import org.openremote.model.event.shared.SharedEvent
import org.openremote.model.gateway.*
import org.openremote.model.geo.GeoJSONPoint
@@ -44,9 +41,9 @@ import spock.lang.Specification
import spock.util.concurrent.PollingConditions
import java.nio.file.Paths
-import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.CopyOnWriteArrayList
import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicReference
+import java.util.function.Consumer
import java.util.stream.Collectors
import java.util.stream.IntStream
@@ -68,7 +65,7 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
def conditions = new PollingConditions(timeout: 15, delay: 0.2)
def container = startContainer(defaultConfig(), defaultServices())
def assetProcessingService = container.getService(AssetProcessingService.class)
- def executorService = container.getExecutorService()
+ def executorService = container.getScheduledExecutor()
def timerService = container.getService(TimerService.class)
def assetStorageService = container.getService(AssetStorageService.class)
def agentService = container.getService(AgentService.class)
@@ -106,7 +103,7 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
}
when: "the Gateway client is created"
- def gatewayClient = new WebsocketIOClient<String>(
+ def gatewayClient = new GatewayIOClient(
new URIBuilder("ws://127.0.0.1:$serverPort/websocket/events?Realm=$managerTestSetup.realmBuildingName").build(),
null,
new OAuthClientCredentialsGrant("http://127.0.0.1:$serverPort/auth/realms/$managerTestSetup.realmBuildingName/protocol/openid-connect/token",
@@ -131,27 +128,25 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
and: "the gateway connects to this manager"
gatewayClient.connect()
- then: "the gateway netty client status should become CONNECTED"
+ then: "the gateway netty client status should become CONNECTING"
conditions.eventually {
- assert connectionStatus == ConnectionStatus.CONNECTED
- assert gatewayClient.connectionStatus == ConnectionStatus.CONNECTED
+ assert connectionStatus == ConnectionStatus.CONNECTING
+ assert gatewayClient.connectionStatus == ConnectionStatus.CONNECTING
}
- and: "the gateway asset connection status should be CONNECTED"
+ and: "the gateway asset connection status should be CONNECTING"
conditions.eventually {
gateway = assetStorageService.find(gateway.getId()) as GatewayAsset
- assert gateway.getGatewayStatus().orElse(null) == ConnectionStatus.CONNECTED
+ assert gateway.getGatewayStatus().orElse(null) == ConnectionStatus.CONNECTING
}
and: "the server should have sent an asset read request"
conditions.eventually {
assert clientReceivedMessages.size() >= 1
- assert clientReceivedMessages[0].startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX)
- def response = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(EventRequestResponseWrapper.MESSAGE_PREFIX.length()), EventRequestResponseWrapper.class)
- assert response.messageId == GatewayConnector.ASSET_READ_EVENT_NAME_INITIAL
- def localReadAssetsEvent = response.event as ReadAssetsEvent
- assert localReadAssetsEvent.assetQuery != null
- assert localReadAssetsEvent.assetQuery.recursive
+ def request = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(SharedEvent.MESSAGE_PREFIX.length()), ReadAssetsEvent.class)
+ assert request.messageID == GatewayConnector.ASSET_READ_EVENT_NAME_INITIAL
+ assert request.assetQuery != null
+ assert request.assetQuery.recursive
}
when: "the previously received messages are cleared"
@@ -228,21 +223,18 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
List<Asset> sendAssets = []
sendAssets.addAll(agentAssets)
sendAssets.addAll(assets)
- def readAssetsReplyEvent = new EventRequestResponseWrapper(
- GatewayConnector.ASSET_READ_EVENT_NAME_INITIAL,
- new AssetsEvent(sendAssets))
- gatewayClient.sendMessage(EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
+ def readAssetsReplyEvent = new AssetsEvent(sendAssets)
+ readAssetsReplyEvent.setMessageID(GatewayConnector.ASSET_READ_EVENT_NAME_INITIAL)
+ gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
then: "the central manager should have requested the full loading of the first batch of assets"
String messageId = null
ReadAssetsEvent readAssetsEvent = null
conditions.eventually {
assert clientReceivedMessages.size() == 1
- assert clientReceivedMessages.get(0).startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX)
assert clientReceivedMessages.get(0).contains("read-assets")
- def response = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(EventRequestResponseWrapper.MESSAGE_PREFIX.length()), EventRequestResponseWrapper.class)
- messageId = response.messageId
- readAssetsEvent = response.event as ReadAssetsEvent
+ readAssetsEvent = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(SharedEvent.MESSAGE_PREFIX.length()), ReadAssetsEvent.class)
+ messageId = readAssetsEvent.messageID
assert messageId == GatewayConnector.ASSET_READ_EVENT_NAME_BATCH + "0"
assert readAssetsEvent.assetQuery != null
assert readAssetsEvent.assetQuery.ids != null
@@ -255,11 +247,9 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
sendAssets = []
sendAssets.addAll(agentAssets)
sendAssets.addAll(Arrays.stream(readAssetsEvent.assetQuery.ids).filter{!agentAssetIds.contains(it)}.map{id -> assets.stream().filter{asset -> asset.id == id}.findFirst().orElse(null)}.collect(Collectors.toList()))
- readAssetsReplyEvent = new EventRequestResponseWrapper(
- messageId,
- new AssetsEvent(sendAssets)
- )
- gatewayClient.sendMessage(EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
+ readAssetsReplyEvent = new AssetsEvent(sendAssets)
+ readAssetsReplyEvent.setMessageID(messageId)
+ gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
then: "the central manager should have added the first batch of assets under the gateway asset"
conditions.eventually {
@@ -305,11 +295,9 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
and: "the central manager should have requested the full loading of the second batch of assets"
conditions.eventually {
assert clientReceivedMessages.size() == 2
- assert clientReceivedMessages.get(1).startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX)
assert clientReceivedMessages.get(1).contains("read-assets")
- def response = ValueUtil.JSON.readValue(clientReceivedMessages[1].substring(EventRequestResponseWrapper.MESSAGE_PREFIX.length()), EventRequestResponseWrapper.class)
- messageId = response.messageId
- readAssetsEvent = response.event as ReadAssetsEvent
+ readAssetsEvent = ValueUtil.JSON.readValue(clientReceivedMessages[1].substring(SharedEvent.MESSAGE_PREFIX.length()), ReadAssetsEvent.class)
+ messageId = readAssetsEvent.messageID
assert messageId == GatewayConnector.ASSET_READ_EVENT_NAME_BATCH + GatewayConnector.SYNC_ASSET_BATCH_SIZE
assert readAssetsEvent.assetQuery != null
assert readAssetsEvent.assetQuery.ids != null
@@ -320,16 +308,48 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
when: "the gateway returns the requested assets"
sendAssets = []
sendAssets.addAll(Arrays.stream(readAssetsEvent.assetQuery.ids).map{id -> assets.stream().filter{asset -> asset.id == id}.findFirst().orElse(null)}.collect(Collectors.toList()))
- readAssetsReplyEvent = new EventRequestResponseWrapper(
- messageId,
- new AssetsEvent(sendAssets))
- gatewayClient.sendMessage(EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
+ readAssetsReplyEvent = new AssetsEvent(sendAssets)
+ readAssetsReplyEvent.setMessageID(messageId)
+ gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
- then: "the gateway connector sync should be completed"
+ then: "the gateway connector initial sync should be completed"
+ conditions.eventually {
+ def gatewayConnector = gatewayService.gatewayConnectorMap.get(gateway.getId().toLowerCase(Locale.ROOT))
+ assert gatewayConnector.isConnected()
+ assert !gatewayConnector.isInitialSyncInProgress()
+ }
+
+ and: "the central manager should have requested the capabilities of the gateway"
+ conditions.eventually {
+ assert clientReceivedMessages.size() == 3
+ assert clientReceivedMessages.get(2).contains(GatewayCapabilitiesRequestEvent.TYPE)
+ def gatewayCapabilitiesRequest = ValueUtil.JSON.readValue(clientReceivedMessages[2].substring(SharedEvent.MESSAGE_PREFIX.length()), GatewayCapabilitiesRequestEvent.class)
+ messageId = gatewayCapabilitiesRequest.messageID
+ }
+
+ when: "the gateway returns the capabilities"
+ def capabilitiesReplyEvent = new GatewayCapabilitiesResponseEvent(true)
+ capabilitiesReplyEvent.setMessageID(messageId)
+ gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(capabilitiesReplyEvent).get())
+
+ then: "the gateway connector capabilities should be updated"
conditions.eventually {
def gatewayConnector = gatewayService.gatewayConnectorMap.get(gateway.getId().toLowerCase(Locale.ROOT))
assert gatewayConnector.isConnected()
assert !gatewayConnector.isInitialSyncInProgress()
+ assert gatewayConnector.isTunnellingSupported()
+ }
+
+ and: "the gateway client should now be CONNECTED"
+ conditions.eventually {
+ assert connectionStatus == ConnectionStatus.CONNECTED
+ assert gatewayClient.connectionStatus == ConnectionStatus.CONNECTED
+ }
+
+ and: "the gateway asset connection status should be CONNECTED"
+ conditions.eventually {
+ gateway = assetStorageService.find(gateway.getId()) as GatewayAsset
+ assert gateway.getGatewayStatus().orElse(null) == ConnectionStatus.CONNECTED
}
and: "all the gateway assets should be replicated underneath the gateway"
@@ -447,77 +467,31 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
when: "the client received messages are cleared"
clientReceivedMessages.clear()
- and: "an asset is added under the gateway in the local manager and the gateway responds that it successfully added the asset"
- def responseFuture = new AtomicReference<ScheduledFuture>()
- responseFuture.set(executorService.scheduleAtFixedRate({
- if (!clientReceivedMessages.isEmpty()) {
- def assetAddEvent = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(SharedEvent.MESSAGE_PREFIX.length()), AssetEvent.class)
- if (assetAddEvent.cause == AssetEvent.Cause.CREATE && assetAddEvent.asset.id == building1Room5AssetId) {
- gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(new AssetEvent(AssetEvent.Cause.CREATE, building1Room5Asset, null)).get())
- responseFuture.get().cancel(false)
- }
- }
- }, 100, 100, TimeUnit.MILLISECONDS))
+ and: "an attempt is made to add a child asset to the gateway in the local manager"
assetStorageService.merge(localBuilding1Room5Asset)
- localBuilding1Room5Asset = assetStorageService.find(mapAssetId(gateway.id, building1Room5AssetId, false)) // Re-fetch asset as modifying instance returned by merge will cause concurrency issues
- then: "the asset should have been added to the gateway and eventually replicated in the local manager"
- assert localBuilding1Room5Asset != null
- assert assetStorageService.find(mapAssetId(gateway.id, building1Room5AssetId, false)).version == localBuilding1Room5Asset.version
+ then: "an exception should be thrown"
+ thrown(IllegalStateException)
when: "the client received messages are cleared"
clientReceivedMessages.clear()
- and: "an asset is modified under the gateway in the local manager and the gateway responds that it successfully updated the asset"
+ and: "an attempt is made to modify a child asset of the gateway in the local manager"
localBuilding1Room5Asset.setName("Test Building 1 Room 5")
localBuilding1Room5Asset.getAttributes().remove("co2Level")
- responseFuture.set(executorService.scheduleAtFixedRate({
- if (!clientReceivedMessages.isEmpty()) {
- def assetAddEvent = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(SharedEvent.MESSAGE_PREFIX.length()), AssetEvent.class)
- if (assetAddEvent.cause == AssetEvent.Cause.UPDATE && assetAddEvent.asset.id == building1Room5AssetId) {
- building1Room5Asset.setName(localBuilding1Room5Asset.name)
- building1Room5Asset.getAttributes().remove("co2Level")
- gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(new AssetEvent(AssetEvent.Cause.UPDATE, building1Room5Asset, null)).get())
- responseFuture.get().cancel(false)
- }
- }
- }, 100, 100, TimeUnit.MILLISECONDS))
localBuilding1Room5Asset = assetStorageService.merge(localBuilding1Room5Asset)
- def version = localBuilding1Room5Asset.version
- localBuilding1Room5Asset = assetStorageService.find(mapAssetId(gateway.id, building1Room5AssetId, false)) // Re-fetch asset as modifying instance returned by merge will cause concurrency issues
- then: "the asset should also be updated in the local manager"
- assert localBuilding1Room5Asset != null
- assert localBuilding1Room5Asset.getVersion() == 2
- assert localBuilding1Room5Asset.getName() == "Test Building 1 Room 5"
- assert localBuilding1Room5Asset.getType() == RoomAsset.DESCRIPTOR.getName()
- assert localBuilding1Room5Asset.getRealm() == managerTestSetup.realmBuildingName
- assert localBuilding1Room5Asset.getParentId() == mapAssetId(gateway.id, assetIds[0], false)
- assert localBuilding1Room5Asset.getAttributes().size() == 6
- assert localBuilding1Room5Asset.version == version
+ then: "an exception should be thrown"
+ thrown(IllegalStateException)
- when: "the client received messages are cleared"
- clientReceivedMessages.clear()
+ when: "an attempt is made to delete a child asset of the gateway in the local manager"
+ assetStorageService.delete([mapAssetId(gateway.id, assetIds[0], false)])
- and: "an asset is deleted under the gateway in the local manager and the gateway responds that it successfully deleted the asset"
- responseFuture.set(executorService.scheduleAtFixedRate({
- if (!clientReceivedMessages.isEmpty()) {
- def request = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(EventRequestResponseWrapper.MESSAGE_PREFIX.length()), EventRequestResponseWrapper.class)
- def deleteRequest = request.event as DeleteAssetsRequestEvent
- if (deleteRequest.assetIds.size() == 1 && deleteRequest.assetIds.get(0) == building1Room5AssetId) {
- gatewayClient.sendMessage(EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.asJSON(new EventRequestResponseWrapper(request.messageId, new DeleteAssetsResponseEvent(true, deleteRequest.assetIds))).get())
- gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(new AssetEvent(AssetEvent.Cause.DELETE, building1Room5Asset, null)).get())
- responseFuture.get().cancel(false)
- }
- }
- }, 100, 100, TimeUnit.MILLISECONDS))
- def deleted = assetStorageService.delete([mapAssetId(gateway.id, building1Room5AssetId, false)])
+ then: "an exception should be thrown"
+ thrown(IllegalStateException)
- then: "the asset should have been deleted"
- assert deleted
- conditions.eventually {
- assert assetStorageService.find(mapAssetId(gateway.id, building1Room5AssetId, false)) == null
- }
+ then: "the asset should not have been deleted"
+ assert assetStorageService.find(mapAssetId(gateway.id, assetIds[0], false)) != null
when: "time advances"
advancePseudoClock(1, TimeUnit.SECONDS, container)
@@ -607,22 +581,22 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
})
gatewayClient.connect()
- then: "the gateway netty client status should become CONNECTED"
+ then: "the gateway netty client status should become CONNECTING"
conditions.eventually {
- assert connectionStatus == ConnectionStatus.CONNECTED
- assert gatewayClient.connectionStatus == ConnectionStatus.CONNECTED
+ assert connectionStatus == ConnectionStatus.CONNECTING
+ assert gatewayClient.connectionStatus == ConnectionStatus.CONNECTING
}
- and: "the gateway asset connection status should be CONNECTED"
+ and: "the gateway asset connection status should be CONNECTING"
conditions.eventually {
gateway = assetStorageService.find(gateway.getId())
- assert gateway.getGatewayStatus().orElse(null) == ConnectionStatus.CONNECTED
+ assert gateway.getGatewayStatus().orElse(null) == ConnectionStatus.CONNECTING
}
and: "the local manager should have sent an asset read request"
conditions.eventually {
assert clientReceivedMessages.size() >= 1
- assert clientReceivedMessages.find {it.startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX) && it.contains("read-assets")} != null
+ assert clientReceivedMessages.find {it.startsWith(SharedEvent.MESSAGE_PREFIX) && it.contains("read-assets")} != null
}
when: "the previously received messages are cleared"
@@ -632,20 +606,16 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
sendAssets = [building1Room5Asset]
sendAssets.addAll(agentAssets)
sendAssets.addAll(assets)
- readAssetsReplyEvent = new EventRequestResponseWrapper(
- GatewayConnector.ASSET_READ_EVENT_NAME_INITIAL,
- new AssetsEvent(sendAssets)
- )
- gatewayClient.sendMessage(EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
+ readAssetsReplyEvent = new AssetsEvent(sendAssets)
+ readAssetsReplyEvent.setMessageID(GatewayConnector.ASSET_READ_EVENT_NAME_INITIAL)
+ gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
then: "the central manager should have requested the full loading of the first batch of assets"
conditions.eventually {
assert clientReceivedMessages.size() == 1
- assert clientReceivedMessages.get(0).startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX)
assert clientReceivedMessages.get(0).contains("read-assets")
- def request = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(EventRequestResponseWrapper.MESSAGE_PREFIX.length()), EventRequestResponseWrapper.class)
- messageId = request.messageId
- readAssetsEvent = request.event as ReadAssetsEvent
+ readAssetsEvent = ValueUtil.JSON.readValue(clientReceivedMessages[0].substring(SharedEvent.MESSAGE_PREFIX.length()), ReadAssetsEvent.class)
+ messageId = readAssetsEvent.messageID
assert messageId == GatewayConnector.ASSET_READ_EVENT_NAME_BATCH + "0"
assert readAssetsEvent.assetQuery != null
assert readAssetsEvent.assetQuery.ids != null
@@ -688,17 +658,16 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
sendAssets = [building1Room5Asset]
sendAssets.addAll(agentAssets)
sendAssets.addAll(Arrays.stream(readAssetsEvent.assetQuery.ids).filter{!agentAssetIds.contains(it) && it != removedAsset.id && it != building1Room5Asset.id}.map{id -> assets.stream().filter{it.id == id}.findFirst().orElse(null)}.collect(Collectors.toList()))
- readAssetsReplyEvent = new EventRequestResponseWrapper(messageId, new AssetsEvent(sendAssets))
- gatewayClient.sendMessage(EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
+ readAssetsReplyEvent = new AssetsEvent(sendAssets)
+ readAssetsReplyEvent.setMessageID(messageId)
+ gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
then: "the central manager should have requested the full loading of the second batch of assets"
conditions.eventually {
assert clientReceivedMessages.size() == 2
- assert clientReceivedMessages.get(1).startsWith(EventRequestResponseWrapper.MESSAGE_PREFIX)
assert clientReceivedMessages.get(1).contains("read-assets")
- def request = ValueUtil.JSON.readValue(clientReceivedMessages[1].substring(EventRequestResponseWrapper.MESSAGE_PREFIX.length()), EventRequestResponseWrapper.class)
- messageId = request.messageId
- readAssetsEvent = request.event as ReadAssetsEvent
+ readAssetsEvent = ValueUtil.JSON.readValue(clientReceivedMessages[1].substring(SharedEvent.MESSAGE_PREFIX.length()), ReadAssetsEvent.class)
+ messageId = readAssetsEvent.messageID
assert messageId == GatewayConnector.ASSET_READ_EVENT_NAME_BATCH + (GatewayConnector.SYNC_ASSET_BATCH_SIZE - 1)
assert readAssetsEvent.assetQuery != null
assert readAssetsEvent.assetQuery.ids != null
@@ -709,8 +678,9 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
when: "the gateway returns the requested assets"
sendAssets = []
sendAssets.addAll(Arrays.stream(readAssetsEvent.assetQuery.ids).map{id -> assets.stream().filter{asset -> asset.id == id}.findFirst().orElse(null)}.collect(Collectors.toList()))
- readAssetsReplyEvent = new EventRequestResponseWrapper(messageId, new AssetsEvent(sendAssets))
- gatewayClient.sendMessage(EventRequestResponseWrapper.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
+ readAssetsReplyEvent = new AssetsEvent(sendAssets)
+ readAssetsReplyEvent.setMessageID(messageId)
+ gatewayClient.sendMessage(SharedEvent.MESSAGE_PREFIX + ValueUtil.asJSON(readAssetsReplyEvent).get())
then: "the gateway connector sync should be completed"
conditions.eventually {
@@ -719,12 +689,24 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
assert !gatewayConnector.isInitialSyncInProgress()
}
+ and: "the gateway netty client status should become CONNECTED"
+ conditions.eventually {
+ assert connectionStatus == ConnectionStatus.CONNECTED
+ assert gatewayClient.connectionStatus == ConnectionStatus.CONNECTED
+ }
+
+ and: "the gateway asset connection status should be CONNECTED"
+ conditions.eventually {
+ gateway = assetStorageService.find(gateway.getId())
+ assert gateway.getGatewayStatus().orElse(null) == ConnectionStatus.CONNECTED
+ }
+
and: "the gateway should have the correct assets"
def gatewayAssets = assetStorageService.findAll(new AssetQuery().parents(gateway.getId()).recursive(true))
assert gatewayAssets.size() == 2 + agentAssets.size() + assets.size()
when: "the gateway asset is deleted"
- deleted = assetStorageService.delete([gateway.id])
+ def deleted = assetStorageService.delete([gateway.id])
then: "all descendant assets should have been removed"
conditions.eventually {
@@ -860,7 +842,7 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
assert mirroredMicrophone2.getAttribute("test").flatMap{it.getValue()}.orElse("") == "testValue"
}
- when: "an asset is added under the gateway asset"
+ when: "an attempt is made to add an asset under the gateway asset"
def microphone3 = ValueUtil.clone(microphone1)
.setName("Microphone 3")
.setId(null)
@@ -868,19 +850,8 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
.setParentId(mapAssetId(gateway.id, managerTestSetup.area1Id, false))
microphone3 = assetStorageService.merge(microphone3)
- then: "the new asset should have been created in the gateway and also mirrored under the gateway asset"
- assert microphone3.id != null
- conditions.eventually {
- def gatewayMicrophone3 = assetStorageService.find(mapAssetId(gateway.id, microphone3.id, true))
- assert gatewayMicrophone3 != null
- assert gatewayMicrophone3.getAttribute(MicrophoneAsset.SOUND_LEVEL).isPresent()
- }
-
- and: "the new asset microphone level should be correctly linked to the simulator protocol only on the gateway"
- conditions.eventually {
- assert !((SimulatorProtocol)agentService.getProtocolInstance(managerTestSetup.agentId)).linkedAttributes.containsKey(new AttributeRef(microphone3.id, MicrophoneAsset.SOUND_LEVEL.name))
- assert ((SimulatorProtocol)agentService.getProtocolInstance(managerTestSetup.smartCityServiceAgentId)).linkedAttributes.containsKey(new AttributeRef(mapAssetId(gateway.id, microphone3.id, true), MicrophoneAsset.SOUND_LEVEL.name))
- }
+ then: "an exception should be thrown"
+ thrown(IllegalStateException)
when: "an attribute is updated on the gateway client"
assetProcessingService.sendAttributeEvent(new AttributeEvent(microphone2.id, "test", "newValue"))
@@ -909,17 +880,17 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
}
when: "we subscribe to attribute events"
- List<AttributeEvent> attributeEvents = []
- def subscriptionId = clientEventService.addInternalSubscription(AttributeEvent.class, null, {attributeEvent ->
+ List<AttributeEvent> attributeEvents = new CopyOnWriteArrayList<>()
+ Consumer<AttributeEvent> eventConsumer = { attributeEvent ->
attributeEvents.add(attributeEvent)
- })
+ }
+ clientEventService.addSubscription(AttributeEvent.class, null, eventConsumer)
and: "an attribute with an attribute link is updated on the gateway"
assetProcessingService.sendAttributeEvent(new AttributeEvent(managerTestSetup.light2Id, LightAsset.ON_OFF, true))
then: "only four attribute events should have been generated, one for each of light1 and light2 and one for each of their mirrored assets below the gateway asset"
- Thread.sleep(1000)
- conditions.eventually {
+ delayedConditions.eventually {
assert attributeEvents.size() == 4
assert attributeEvents.any{it.id == managerTestSetup.light2Id && it.name == LightAsset.ON_OFF.name && it.value.orElse(false)}
assert attributeEvents.any{it.id == managerTestSetup.light1Id && it.name == LightAsset.ON_OFF.name && it.value.orElse(false)}
@@ -945,8 +916,8 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
// Ignore any other attribute
new GatewayAttributeFilter().setSkipAlways(true)
])
- gatewayClientResource.setConnection(null, managerTestSetup.realmCityName, gatewayConnection)
def oldClient = gatewayClientService.clientRealmMap.get(gatewayConnection.getLocalRealm())
+ gatewayClientResource.setConnection(null, managerTestSetup.realmCityName, gatewayConnection)
then: "the gateway connection IO client should have been replaced and synchronisation should be complete"
conditions.eventually {
@@ -955,6 +926,7 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
GatewayConnector connector = gatewayService.gatewayConnectorMap.get(gateway.getId().toLowerCase(Locale.ROOT))
assert connector != null
assert !connector.initialSyncInProgress
+ assert attributeEvents.any{it.id == gateway.id && it.value.get() == ConnectionStatus.CONNECTED}
}
when: "an attribute event occurs in the edge gateway realm for an attribute with a value change filter and the attribute value has not changed"
@@ -1032,8 +1004,11 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
}
cleanup: "Remove any subscriptions created"
- if (clientEventService != null && subscriptionId != null) {
- clientEventService.cancelInternalSubscription(subscriptionId)
+ if (clientEventService != null) {
+ clientEventService.removeSubscription(eventConsumer)
+ }
+ if (gateway != null) {
+ assetStorageService.delete([gateway.id])
}
}
@@ -1054,7 +1029,7 @@ class GatewayTest extends Specification implements ManagerContainerTrait {
def container = startContainer(defaultConfig() << [(GatewayService.OR_GATEWAY_TUNNEL_SSH_KEY_FILE): keyPath.toAbsolutePath().toString()], defaultServices())
def gatewayClientService = container.getService(GatewayClientService)
def tunnelFactory = gatewayClientService.gatewayTunnelFactory as JSchGatewayTunnelFactory
- def client = WebTargetBuilder.createClient(container.getExecutorService())
+ def client = WebTargetBuilder.createClient(container.getScheduledExecutor())
def tunnelInfo = new GatewayTunnelInfo(
"",
UniqueIdentifierGenerator.generateId(),
diff --git a/test/src/test/groovy/org/openremote/test/mqtt/MqttBrokerTest.groovy b/test/src/test/groovy/org/openremote/test/mqtt/MqttBrokerTest.groovy
index 5a355305b..d3b66582f 100644
--- a/test/src/test/groovy/org/openremote/test/mqtt/MqttBrokerTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/mqtt/MqttBrokerTest.groovy
@@ -32,6 +32,7 @@ import org.openremote.setup.integration.ManagerTestSetup
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
+import java.util.concurrent.CopyOnWriteArrayList
import java.util.function.Consumer
import static org.openremote.container.util.MapAccess.getInteger
@@ -45,8 +46,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
def "Mqtt broker event test"() {
given: "the container environment is started"
- List<SharedEvent> receivedEvents = []
- List<Object> receivedValues = []
+ List<SharedEvent> receivedEvents = new CopyOnWriteArrayList<>()
+ List<Object> receivedValues = new CopyOnWriteArrayList<>()
MQTT_IOClient client = null
MQTT_IOClient newClient = null
def conditions = new PollingConditions(timeout: 15, initialDelay: 0.1, delay: 0.2)
@@ -56,6 +57,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
def mqttBrokerService = container.getService(MQTTBrokerService.class)
def assetStorageService = container.getService(AssetStorageService.class)
def clientEventService = container.getService(ClientEventService.class)
+ def defaultMQTTHandler = mqttBrokerService.getCustomHandlers().find {it instanceof DefaultMQTTHandler} as DefaultMQTTHandler
def agentService = container.getService(AgentService.class)
def mqttClientId = UniqueIdentifierGenerator.generateId()
def username = keycloakTestSetup.realmBuilding.name + ":" + keycloakTestSetup.serviceUser.username // realm and OAuth client id
@@ -84,8 +86,6 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.getConnectionStatus() == ConnectionStatus.CONNECTED
assert mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id).size() == 1
- def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.sessionKeyInfoMap.containsKey(getConnectionIDString(connection))
}
when: "the client disconnects"
@@ -94,8 +94,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
then: "the client resources should be freed"
conditions.eventually {
- assert clientEventService.sessionKeyInfoMap.isEmpty()
- assert !clientEventService.sessionKeyInfoMap.containsKey(getConnectionIDString(currentConnection))
+ assert client.getConnectionStatus() == ConnectionStatus.DISCONNECTED
+ assert mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id).isEmpty()
}
when: "a mqtt client connects with valid credentials"
@@ -107,8 +107,6 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.getConnectionStatus() == ConnectionStatus.CONNECTED
assert mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id).size() == 1
- def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.sessionKeyInfoMap.containsKey(getConnectionIDString(connection))
}
when: "a mqtt client subscribes to an asset in another realm"
@@ -119,7 +117,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.topicConsumerMap.get(topic) == null // Consumer added and removed on failure
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
when: "a mqtt client subscribes with clientId missing"
@@ -130,7 +128,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.topicConsumerMap.get(topic) == null // Consumer added and removed on failure
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
when: "a mqtt client subscribes with different clientId"
@@ -143,7 +141,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
assert client.topicConsumerMap.get(topic) == null // Consumer added and removed on failure
assert mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id).size() == 1
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
when: "a mqtt client subscribes to all attributes of an asset"
@@ -160,8 +158,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
assert client.topicConsumerMap.get(topic).size() == 1
assert mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id).size() == 1
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 1
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
}
when: "An attribute event occurs for a subscribed attribute"
@@ -248,7 +246,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.topicConsumerMap.get(topic) == null
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
when: "another asset attribute changed without any subscriptions"
@@ -269,8 +267,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
assert client.topicConsumerMap.get(topic) != null
assert client.topicConsumerMap.get(topic).size() == 1
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 1
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
}
when: "that attribute changes"
@@ -303,7 +301,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.topicConsumerMap.get(topic) == null
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
when: "a mqtt client subscribes to attributes for descendants of an asset"
@@ -315,8 +313,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
assert client.topicConsumerMap.get(topic) != null
assert client.topicConsumerMap.get(topic).size() == 1
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 1
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
}
when: "a child asset of the subscription attribute event occurs"
@@ -345,8 +343,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
assert client.topicConsumerMap.get(topic) != null
assert client.topicConsumerMap.get(topic).size() == 1
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 2
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 2
}
when: "a subscribed attribute changes"
@@ -388,8 +386,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
assert client.topicConsumerMap.get(topic) == null
assert client.topicConsumerMap.size() == 1
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 1
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
}
when: "a client disconnects"
@@ -418,8 +416,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
then: "A subscription should exist"
conditions.eventually {
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 1
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
}
when: "an asset is updated with a new attribute"
@@ -445,8 +443,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.topicConsumerMap.get(topic) != null
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 2
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 2
}
when: "an asset is added as a descendant to the subscribed asset"
@@ -471,8 +469,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert client.topicConsumerMap.get(topic) == null
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 1
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
}
when: "the descendant asset is modified"
@@ -600,7 +598,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert newClient.topicConsumerMap.get(topic) == null // Consumer added and removed on failure
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser2.id)[0]
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
when: "a restricted mqtt client subscribes to a linked asset"
@@ -611,8 +609,8 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert newClient.topicConsumerMap.get(topic) != null
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser2.id)[0]
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 1
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 1
}
when: "a user asset link is added for a connected restricted user"
@@ -655,7 +653,7 @@ class MqttBrokerTest extends Specification implements ManagerContainerTrait {
conditions.eventually {
assert newClient.topicConsumerMap.get(topic) == null // Consumer added and removed on failure
def connection = mqttBrokerService.getUserConnections(keycloakTestSetup.serviceUser2.id)[0]
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
// TODO: Further MQTT tests
diff --git a/test/src/test/groovy/org/openremote/test/protocol/TcpClientTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/TcpClientTest.groovy
index d684089a9..658aeef0e 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/TcpClientTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/TcpClientTest.groovy
@@ -28,14 +28,10 @@ import org.openremote.agent.protocol.tcp.TCPIOClient
import org.openremote.agent.protocol.tcp.TCPStringServer
import org.openremote.container.timer.TimerService
import org.openremote.model.asset.agent.ConnectionStatus
-import org.openremote.model.notification.AbstractNotificationMessage
-import org.openremote.model.notification.Notification
import org.openremote.test.ManagerContainerTrait
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
-import java.util.concurrent.Future
-
/**
* This tests the {@link TCPIOClient} by creating a simple echo server that the client communicates with
*/
@@ -44,7 +40,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
def "Check client"() {
given: "expected conditions"
- def conditions = new PollingConditions(timeout: 20, delay: 0.2)
+ def conditions = new PollingConditions(timeout: 60, delay: 0.2)
and: "the container is started"
def container = startContainer(defaultConfig(), [new TimerService()])
@@ -67,13 +63,13 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
})
and: "we add callback consumers to the client"
- def connectionStatus = client.getConnectionStatus()
+ def connectionStatuses = [client.getConnectionStatus()]
String lastMessage
client.addMessageConsumer({
message -> lastMessage = message
})
client.addConnectionStatusConsumer({
- status -> connectionStatus = status
+ status -> connectionStatuses.add(status)
})
when: "the server is started"
@@ -91,7 +87,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
then: "the client status should become CONNECTED"
conditions.eventually {
// assert client.connectionStatus == ConnectionStatus.CONNECTED
- assert connectionStatus == ConnectionStatus.CONNECTED
+ assert connectionStatuses.last() == ConnectionStatus.CONNECTED
assert echoServer.allChannels.size() == 1
}
@@ -117,7 +113,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
then: "the client should become DISCONNECTED"
conditions.eventually {
// assert client.connectionStatus == ConnectionStatus.DISCONNECTED
- assert connectionStatus == ConnectionStatus.DISCONNECTED
+ assert connectionStatuses.last() == ConnectionStatus.DISCONNECTED
}
when: "we reconnect the same client"
@@ -126,7 +122,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
then: "the client status should become CONNECTED"
conditions.eventually {
// assert client.connectionStatus == ConnectionStatus.CONNECTED
- assert connectionStatus == ConnectionStatus.CONNECTED
+ assert connectionStatuses.last() == ConnectionStatus.CONNECTED
assert echoServer.allChannels.size() == 1
}
@@ -147,6 +143,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
}
when: "we lose connection to the server"
+ connectionStatuses.clear()
client.connectAttempts = 0
echoServer.stop()
@@ -158,7 +155,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
then: "the client status should change to CONNECTING and several re-connection attempts should be made"
conditions.eventually {
// assert client.connectionStatus == ConnectionStatus.CONNECTING
- assert connectionStatus == ConnectionStatus.CONNECTING
+ assert connectionStatuses.contains(ConnectionStatus.CONNECTING)
assert client.connectAttempts > 2
}
@@ -177,7 +174,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
then: "the client status should become CONNECTED"
conditions.eventually {
// assert client.connectionStatus == ConnectionStatus.CONNECTED
- assert connectionStatus == ConnectionStatus.CONNECTED
+ assert connectionStatuses.last() == ConnectionStatus.CONNECTED
assert echoServer.allChannels.size() == 1
}
@@ -203,7 +200,7 @@ class TcpClientTest extends Specification implements ManagerContainerTrait {
then: "the client should become DISCONNECTED"
conditions.eventually {
// assert client.connectionStatus == ConnectionStatus.DISCONNECTED
- assert connectionStatus == ConnectionStatus.DISCONNECTED
+ assert connectionStatuses.last() == ConnectionStatus.DISCONNECTED
}
cleanup: "the server should be stopped"
diff --git a/test/src/test/groovy/org/openremote/test/protocol/http/HttpClientProtocolTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/http/HttpClientProtocolTest.groovy
index a06b3156f..0802b963c 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/http/HttpClientProtocolTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/http/HttpClientProtocolTest.groovy
@@ -52,7 +52,6 @@ import spock.lang.Shared
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
-import java.time.LocalDateTime
import java.time.ZoneId
import java.time.format.DateTimeFormatter
import java.time.temporal.ChronoField
@@ -235,13 +234,13 @@ class HttpClientProtocolTest extends Specification implements ManagerContainerTr
def yearMonthDay = doDynamicTimeReplace('%TIME:yyyy-MM-dd%', getInstantTimeOf(container))
def epochMillis = getInstantTimeOf(container).plus(1, ChronoUnit.HOURS).toEpochMilli()
def epochSeconds = getInstantTimeOf(container).minus(50, ChronoUnit.DAYS).getEpochSecond()
- def localInstant = LocalDateTime.ofInstant(getInstantTimeOf(container), ZoneId.systemDefault())
+ def localDateTime = getInstantTimeOf(container).atZone(ZoneId.systemDefault()).toLocalDateTime()
if (yearMonthDay.substring(4,5) != '-'
|| yearMonthDay.substring(7,8) != '-'
- || yearMonthDay.substring(0,4) != Integer.toString(localInstant.get(ChronoField.YEAR))
- || !yearMonthDay.substring(5,7).contains(Integer.toString(localInstant.get(ChronoField.MONTH_OF_YEAR)))
- || !yearMonthDay.substring(8,10).contains(Integer.toString(localInstant.get(ChronoField.DAY_OF_MONTH)))
+ || yearMonthDay.substring(0,4) != Integer.toString(localDateTime.get(ChronoField.YEAR))
+ || !yearMonthDay.substring(5,7).contains(Integer.toString(localDateTime.get(ChronoField.MONTH_OF_YEAR)))
+ || !yearMonthDay.substring(8,10).contains(Integer.toString(localDateTime.get(ChronoField.DAY_OF_MONTH)))
) {
requestContext.abortWith(Response.status(Response.Status.BAD_REQUEST).build())
return
diff --git a/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientProtocolTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientProtocolTest.groovy
index de4bcbc2c..481817353 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientProtocolTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientProtocolTest.groovy
@@ -38,11 +38,17 @@ import org.openremote.model.attribute.AttributeEvent
import org.openremote.model.attribute.MetaItem
import org.openremote.model.auth.UsernamePassword
import org.openremote.model.query.filter.StringPredicate
+import org.openremote.model.util.UniqueIdentifierGenerator
import org.openremote.test.ManagerContainerTrait
import spock.lang.Shared
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.TimeUnit
+import java.util.function.Consumer
+
import static org.openremote.model.value.MetaItemType.AGENT_LINK
import static org.openremote.model.value.ValueType.TEXT
@@ -87,12 +93,7 @@ class MailClientProtocolTest extends Specification implements ManagerContainerTr
def "Basic agent and attribute linking"() {
given: "expected conditions"
- def conditions = new PollingConditions(timeout: 20, delay: 0.2)
-
- and: "some mailbox messages"
- sendMessage("from@localhost")
- sendMessage("from@localhost")
- sendMessage("from@localhost")
+ def conditions = new PollingConditions(timeout: 30, delay: 0.2)
and: "the container starts"
def container = startContainer(defaultConfig(), defaultServices())
@@ -100,10 +101,20 @@ class MailClientProtocolTest extends Specification implements ManagerContainerTr
def assetProcessingService = container.getService(AssetProcessingService.class)
def agentService = container.getService(AgentService.class)
def clientEventService = container.getService(ClientEventService.class)
- List<AttributeEvent> attributeEvents = []
- def eventSessionID = clientEventService.addInternalSubscription(AttributeEvent.class, null, it -> {
+ ThingAsset asset = null
+ def attributeEvents = new CopyOnWriteArrayList<AttributeEvent>()
+ Consumer<AttributeEvent> eventConsumer = it -> {
attributeEvents.add(it)
- })
+ }
+ clientEventService.addSubscription(AttributeEvent.class, null, eventConsumer)
+
+ and: "some mail messages exist"
+ sendMessage("from@localhost")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
+ sendMessage("from@localhost")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
+ sendMessage("from@localhost")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
when: "a mail client agent is created"
def agent = new MailAgent("Test agent")
@@ -119,7 +130,8 @@ class MailClientProtocolTest extends Specification implements ManagerContainerTr
agent = assetStorageService.merge(agent)
and: "an asset is created with attributes linked to the agent"
- def asset = new ThingAsset("Test Asset")
+ asset = new ThingAsset("Test Asset")
+ .setId(UniqueIdentifierGenerator.generateId("MailTestAsset"))
.setParent(agent)
.addOrReplaceAttributes(
new Attribute<>("fromMatchUseBody", TEXT)
@@ -188,10 +200,15 @@ class MailClientProtocolTest extends Specification implements ManagerContainerTr
when: "more messages are received in the mailbox"
sendMessage("from@localhost")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
sendMessage("1from@localhost")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
sendMessage("from@localhost")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
sendMessage("from@localhost", "Not A Test", "Not a test body 1")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
sendMessage("fromanother@localhost", "Not A Test", "Not a test body 2")
+ advancePseudoClock(1, TimeUnit.SECONDS, container)
then: "the matching linked attributes should have been updated with the new mailbox messages"
conditions.eventually {
@@ -218,8 +235,8 @@ class MailClientProtocolTest extends Specification implements ManagerContainerTr
}
cleanup: "the event subscription is removed"
- if (eventSessionID != null) {
- clientEventService.cancelInternalSubscription(eventSessionID)
+ if (clientEventService != null) {
+ clientEventService.removeSubscription(eventConsumer)
}
if (asset != null) {
assetStorageService.delete([agent.id, asset.id])
diff --git a/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientTest.groovy
index 9fbd19741..e2e3b2964 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/mail/MailClientTest.groovy
@@ -21,6 +21,7 @@ import jakarta.mail.internet.MimeMessage
import jakarta.mail.internet.MimeMultipart
import java.nio.file.Paths
import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.Executors
/*
* Copyright 2023, OpenRemote Inc.
@@ -79,9 +80,11 @@ class MailClientTest extends Specification implements ManagerContainerTrait {
List<ConnectionStatus> connectionEvents = new CopyOnWriteArrayList<>()
List<MailMessage> messages = new CopyOnWriteArrayList<>()
def conditions = new PollingConditions(delay: 1, initialDelay: 1, timeout: 10)
- def executor = new ContainerScheduledExecutor("Scheduled task", 1)
+ def executor = Executors.newCachedThreadPool()
+ def scheduledExecutor = new ContainerScheduledExecutor("Test", 1)
def mailClient = new MailClientBuilder(
executor,
+ scheduledExecutor,
"pop3",
"localhost",
greenMail.getPop3().getServerSetup().getPort())
@@ -157,6 +160,7 @@ class MailClientTest extends Specification implements ManagerContainerTrait {
and: "a new POP3 client is created"
mailClient = new MailClientBuilder(
executor,
+ scheduledExecutor,
"pop3",
"localhost",
greenMail.getPop3().getServerSetup().getPort())
@@ -209,9 +213,11 @@ class MailClientTest extends Specification implements ManagerContainerTrait {
List<ConnectionStatus> connectionEvents = new CopyOnWriteArrayList<>()
List<MailMessage> messages = new CopyOnWriteArrayList<>()
def conditions = new PollingConditions(delay: 1, initialDelay: 1, timeout: 10)
- def executor = new ContainerScheduledExecutor("Scheduled task", 1)
+ def executor = Executors.newCachedThreadPool()
+ def scheduledExecutor = new ContainerScheduledExecutor("Scheduled task", 1)
def mailClient = new MailClientBuilder(
executor,
+ scheduledExecutor,
"imap",
"localhost",
greenMail.getImap().getServerSetup().getPort())
diff --git a/test/src/test/groovy/org/openremote/test/protocol/mqtt/MQTTClientProtocolTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/mqtt/MQTTClientProtocolTest.groovy
index c27278435..c0aed5544 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/mqtt/MQTTClientProtocolTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/mqtt/MQTTClientProtocolTest.groovy
@@ -86,6 +86,7 @@ class MQTTClientProtocolTest extends Specification implements ManagerContainerTr
def assetProcessingService = container.getService(AssetProcessingService.class)
def agentService = container.getService(AgentService.class)
def brokerService = container.getService(MQTTBrokerService.class)
+ def defaultMQTTHandler = brokerService.getCustomHandlers().find{it instanceof DefaultMQTTHandler} as DefaultMQTTHandler
def managerTestSetup = container.getService(SetupService.class).getTaskOfType(ManagerTestSetup.class)
def keycloakTestSetup = container.getService(SetupService.class).getTaskOfType(KeycloakTestSetup.class)
def clientEventService = container.getService(ClientEventService.class)
@@ -132,7 +133,7 @@ class MQTTClientProtocolTest extends Specification implements ManagerContainerTr
assert !(agentService.getProtocolInstance(agent.id) as MQTTProtocol).protocolMessageConsumers.isEmpty()
def connection = brokerService.getConnectionFromClientID(clientId)
assert connection != null
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
}
when: "the attribute referenced in the agent link is updated"
diff --git a/test/src/test/groovy/org/openremote/test/protocol/udp/UdpClientProtocolTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/udp/UdpClientProtocolTest.groovy
index 3e1d6e92e..52aa848d4 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/udp/UdpClientProtocolTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/udp/UdpClientProtocolTest.groovy
@@ -47,6 +47,8 @@ import org.openremote.test.ManagerContainerTrait
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
+import java.util.concurrent.CopyOnWriteArrayList
+
import static org.openremote.model.value.MetaItemType.*
import static org.openremote.model.value.ValueType.*
@@ -71,7 +73,7 @@ class UdpClientProtocolTest extends Specification implements ManagerContainerTra
def clientActualPort = null
def lastCommand = null
def lastSend = null
- def receivedMessages = []
+ def receivedMessages = new CopyOnWriteArrayList()
echoServer.addMessageConsumer({
message, channel, sender ->
clientActualPort = sender.port
diff --git a/test/src/test/groovy/org/openremote/test/protocol/velbus/VelbusBasicTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/velbus/VelbusBasicTest.groovy
index 385f25d25..63ccf2361 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/velbus/VelbusBasicTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/velbus/VelbusBasicTest.groovy
@@ -31,6 +31,8 @@ import spock.lang.Specification
import spock.util.concurrent.PollingConditions
import org.openremote.setup.integration.protocol.velbus.MockVelbusClient
+import java.util.concurrent.Executors
+
import static spock.util.matcher.HamcrestMatchers.closeTo
class VelbusBasicTest extends Specification {
@@ -811,8 +813,8 @@ class VelbusBasicTest extends Specification {
// def client = new VelbusSerialMessageProcessor("COM6", 38400);
// VelbusNetwork.DELAY_BETWEEN_PACKET_WRITES_MILLISECONDS = 100;
- def scheduledTasksExecutor = new ContainerScheduledExecutor("Scheduled task", Container.OR_SCHEDULED_TASKS_THREADS_MAX_DEFAULT)
- network = new VelbusNetwork(messageProcessor, scheduledTasksExecutor, null)
+ def scheduledTasksExecutor = Executors.newScheduledThreadPool(1)
+ network = new VelbusNetwork(messageProcessor, scheduledTasksExecutor, null)
loadDevicePackets(VelbusBasicTest.messageProcessor)
}
diff --git a/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientProtocolTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientProtocolTest.groovy
index 973b15be4..ef7887243 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientProtocolTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientProtocolTest.groovy
@@ -151,8 +151,7 @@ class WebsocketClientProtocolTest extends Specification implements ManagerContai
new EventSubscription(
AttributeEvent.class,
new AssetFilter<AttributeEvent>().setAssetIds(managerTestSetup.apartment1LivingroomId),
- "1",
- null)).orElse(null)),
+ "1")).orElse(null)),
new WebsocketHTTPSubscription()
.contentType(MediaType.APPLICATION_JSON)
.method(WebsocketHTTPSubscription.Method.POST)
diff --git a/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy b/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy
index 907ea8021..25e6b065c 100644
--- a/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/protocol/websocket/WebsocketClientTest.groovy
@@ -47,6 +47,8 @@ import org.openremote.test.ManagerContainerTrait
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
+import java.util.concurrent.CopyOnWriteArrayList
+
import static org.openremote.container.util.MapAccess.getString
import static org.openremote.manager.security.ManagerIdentityProvider.OR_ADMIN_PASSWORD
import static org.openremote.manager.security.ManagerIdentityProvider.OR_ADMIN_PASSWORD_DEFAULT
@@ -130,8 +132,8 @@ class WebsocketClientTest extends Specification implements ManagerContainerTrait
and: "we add callback consumers to the clients"
def connectionStatus = client.getConnectionStatus()
def connectionStatus2 = client2.getConnectionStatus()
- List<Object> receivedMessages = []
- List<Object> receivedMessages2 = []
+ List<Object> receivedMessages = new CopyOnWriteArrayList<>()
+ List<Object> receivedMessages2 = new CopyOnWriteArrayList<>()
client.addMessageConsumer({
message -> receivedMessages.add(messageFromString(message))
})
@@ -165,28 +167,24 @@ class WebsocketClientTest extends Specification implements ManagerContainerTrait
new EventSubscription(
AttributeEvent.class,
null,
- "attributes",
- null)))
+ "attributes")))
client2.sendMessage(messageToString(EventSubscription.SUBSCRIBE_MESSAGE_PREFIX,
new EventSubscription(
AttributeEvent.class,
null,
- "attributes2",
- null)))
+ "attributes2")))
and: "we subscribe to asset events produced by the server"
client.sendMessage(messageToString(EventSubscription.SUBSCRIBE_MESSAGE_PREFIX,
new EventSubscription(
AssetEvent.class,
null,
- "assets",
- null)))
+ "assets")))
client2.sendMessage(messageToString(EventSubscription.SUBSCRIBE_MESSAGE_PREFIX,
new EventSubscription(
AssetEvent.class,
null,
- "assets2",
- null)))
+ "assets2")))
then: "the server should confirm the subscriptions"
conditions.eventually {
@@ -299,7 +297,7 @@ class WebsocketClientTest extends Specification implements ManagerContainerTrait
and: "we add callback consumers to the client"
def connectionStatus = client.getConnectionStatus()
- List<String> receivedMessages = []
+ List<String> receivedMessages = new CopyOnWriteArrayList<>()
client.addMessageConsumer(
message -> receivedMessages.add(messageFromString(message))
)
@@ -328,8 +326,7 @@ class WebsocketClientTest extends Specification implements ManagerContainerTrait
new EventSubscription(
AttributeEvent.class,
new AssetFilter<AttributeEvent>().setAssetIds(managerTestSetup.apartment1LivingroomId),
- "1",
- null)))
+ "1")))
then: "the server should return a subscribed event"
conditions.eventually {
diff --git a/test/src/test/groovy/org/openremote/test/provisioning/UserAndAssetProvisioningTest.groovy b/test/src/test/groovy/org/openremote/test/provisioning/UserAndAssetProvisioningTest.groovy
index 65b29b173..57fead9e4 100644
--- a/test/src/test/groovy/org/openremote/test/provisioning/UserAndAssetProvisioningTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/provisioning/UserAndAssetProvisioningTest.groovy
@@ -60,6 +60,7 @@ import org.openremote.setup.integration.ManagerTestSetup
import spock.lang.Specification
import spock.util.concurrent.PollingConditions
+import java.util.concurrent.CopyOnWriteArrayList
import java.util.function.Consumer
import static org.openremote.manager.mqtt.MQTTBrokerService.getConnectionIDString
@@ -82,6 +83,7 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
def assetStorageService = container.getService(AssetStorageService.class)
def provisioningService = container.getService(ProvisioningService.class)
def mqttBrokerService = container.getService(MQTTBrokerService.class)
+ def defaultMQTTHandler = mqttBrokerService.getCustomHandlers().find{it instanceof DefaultMQTTHandler} as DefaultMQTTHandler
def clientEventService = container.getService(ClientEventService.class)
def assetProcessingService = container.getService(AssetProcessingService.class)
def identityService = container.getService(ManagerIdentityService.class)
@@ -105,11 +107,11 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
})
and: "an internal attribute event subscriber is added for test validation purposes"
- List<AttributeEvent> internalAttributeEvents = []
+ List<AttributeEvent> internalAttributeEvents = new CopyOnWriteArrayList<>()
Consumer<AttributeEvent> internalConsumer = { ev ->
internalAttributeEvents.add(ev)
}
- clientEventService.addInternalSubscription(AttributeEvent.class, null, internalConsumer)
+ clientEventService.addSubscription(AttributeEvent.class, null, internalConsumer)
// TODO: Switch to use provisioning resource once implemented
when: "a provisioning realm config is added to the system"
@@ -152,8 +154,8 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
RemotingConnection connection = null
def device1UniqueId = "device1"
def mqttDevice1ClientId = UniqueIdentifierGenerator.generateId("device1")
- List<String> subscribeFailures = []
- List<ConnectionStatus> connectionStatuses = []
+ List<String> subscribeFailures = new CopyOnWriteArrayList<>()
+ List<ConnectionStatus> connectionStatuses = new CopyOnWriteArrayList<>()
Consumer<String> subscribeFailureCallback = {String topic -> subscribeFailures.add(topic)}
device1Client = new MQTT_IOClient(mqttDevice1ClientId, mqttHost, mqttPort, false, false, null, null, null)
device1Client.setTopicSubscribeFailureConsumer(subscribeFailureCallback)
@@ -167,7 +169,7 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
}
when: "the client subscribes to the provisioning endpoints"
- List<ProvisioningMessage> device1Responses = []
+ List<ProvisioningMessage> device1Responses = new CopyOnWriteArrayList<>()
Consumer<MQTTMessage<String>> device1MessageConsumer = { MQTTMessage<String> msg ->
device1Responses.add(ValueUtil.parse(msg.payload, ProvisioningMessage.class).orElse(null))
}
@@ -275,8 +277,8 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
def asset = ((SuccessResponseMessage)device1Responses.get(0)).asset
def assetSubscriptionTopic = "$provisioningConfig.realm/$mqttDevice1ClientId/$DefaultMQTTHandler.ASSET_TOPIC/#".toString()
def attributeSubscriptionTopic = "$provisioningConfig.realm/$mqttDevice1ClientId/$DefaultMQTTHandler.ATTRIBUTE_TOPIC/+/$asset.id".toString()
- List<AssetEvent> assetEvents = []
- List<AttributeEvent> attributeEvents = []
+ List<AssetEvent> assetEvents = new CopyOnWriteArrayList<>()
+ List<AttributeEvent> attributeEvents = new CopyOnWriteArrayList<>()
Consumer<MQTTMessage<String>> eventConsumer = { MQTTMessage<String> msg ->
def event = ValueUtil.parse(msg.payload, SharedEvent.class).orElse(null)
if (event instanceof AssetEvent) {
@@ -296,8 +298,8 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
assert device1Client.topicConsumerMap.get(attributeSubscriptionTopic).size() == 1
connection = mqttBrokerService.getConnectionFromClientID(mqttDevice1ClientId)
assert connection != null
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 2
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 2
}
when: "the client updates one of the provisioned asset's attributes"
@@ -352,7 +354,7 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
then: "all subscriptions should be removed and the client should be disconnected"
conditions.eventually {
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
assert device1Client.getConnectionStatus() == ConnectionStatus.DISCONNECTED
}
@@ -421,8 +423,8 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
assert device1Client.topicConsumerMap.get(attributeSubscriptionTopic).size() == 1
connection = mqttBrokerService.getConnectionFromClientID(mqttDevice1ClientId)
assert connection != null
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(connection))
- assert clientEventService.eventSubscriptions.sessionSubscriptionIdMap.get(getConnectionIDString(connection)).size() == 2
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(connection))
+ assert defaultMQTTHandler.sessionSubscriptionConsumers.get(getConnectionIDString(connection)).size() == 2
}
when: "a second device connects"
@@ -441,7 +443,7 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
}
when: "the client subscribes to the provisioning endpoints"
- List<ProvisioningMessage> deviceNResponses = []
+ List<ProvisioningMessage> deviceNResponses = new CopyOnWriteArrayList<>()
Consumer<MQTTMessage<String>> deviceNMessageConsumer = { MQTTMessage<String> msg ->
deviceNResponses.add(ValueUtil.parse(msg.payload, ProvisioningMessage.class).orElse(null))
}
@@ -695,7 +697,7 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
conditions.eventually {
assert mqttBrokerService.getConnectionFromClientID(mqttDevice1ClientId) != null
assert mqttBrokerService.getConnectionFromClientID(mqttDevice1ClientId) != existingConnection
- assert !clientEventService.eventSubscriptions.sessionSubscriptionIdMap.containsKey(getConnectionIDString(existingConnection))
+ assert !defaultMQTTHandler.sessionSubscriptionConsumers.containsKey(getConnectionIDString(existingConnection))
}
when: "the re-connected client re-authenticates"
@@ -781,5 +783,8 @@ class UserAndAssetProvisioningTest extends Specification implements ManagerConta
if (deviceNClient != null) {
deviceNClient.disconnect()
}
+ if (internalConsumer != null) {
+ clientEventService.removeSubscription {internalConsumer}
+ }
}
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/AlarmRuleTest.groovy b/test/src/test/groovy/org/openremote/test/rules/AlarmRuleTest.groovy
index 9d9dd9805..c698d0684 100644
--- a/test/src/test/groovy/org/openremote/test/rules/AlarmRuleTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/AlarmRuleTest.groovy
@@ -127,6 +127,7 @@ class AlarmRuleTest extends Specification implements ManagerContainerTrait {
then: "the ruleset should reach the engine"
def conditions = new PollingConditions(timeout: 10, delay: 0.2)
conditions.eventually {
+ assert rulesService.realmEngines.containsKey(managerTestSetup.realmBuildingName)
def deployment = rulesService.realmEngines.get(managerTestSetup.realmBuildingName).deployments.get(realmRuleset.id)
assert deployment != null
assert deployment.ruleset.version == realmRuleset.version
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
index 19151e026..6b56ad077 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
@@ -63,11 +63,11 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
then: "the global rules engine should load this definition and restart successfully"
conditions.eventually {
- assert rulesService.globalEngine != null
- assert rulesService.globalEngine.isRunning()
- assert rulesService.globalEngine.deployments.size() == 2
- assert rulesService.globalEngine.deployments.values().any({ it.name == "Some global demo rules" && it.status == DEPLOYED})
- assert rulesService.globalEngine.deployments.values().any({ it.name == "Some more global rules" && it.status == DEPLOYED})
+ assert rulesService.globalEngine.get() != null
+ assert rulesService.globalEngine.get().isRunning()
+ assert rulesService.globalEngine.get().deployments.size() == 2
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == "Some global demo rules" && it.status == DEPLOYED})
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == "Some more global rules" && it.status == DEPLOYED})
}
when: "a new realm rule definition is added to Building"
@@ -159,13 +159,13 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
then: "the global rules engine should still run and the rule engine status should indicate the issue"
conditions.eventually {
- assert rulesService.globalEngine.deployments.size() == 3
- assert rulesService.globalEngine.running
- assert !rulesService.globalEngine.isError()
- assert rulesService.globalEngine.error instanceof RuntimeException
- assert rulesService.globalEngine.deployments.values().any({ it.name == "Some global demo rules" && it.status == DEPLOYED})
- assert rulesService.globalEngine.deployments.values().any({ it.name == "Some more global rules" && it.status == DEPLOYED})
- assert rulesService.globalEngine.deployments.values().any({ it.name == "Some broken global rules" && it.status == COMPILATION_ERROR})
+ assert rulesService.globalEngine.get().deployments.size() == 3
+ assert rulesService.globalEngine.get().running
+ assert !rulesService.globalEngine.get().isError()
+ assert rulesService.globalEngine.get().error instanceof RuntimeException
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == "Some global demo rules" && it.status == DEPLOYED})
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == "Some more global rules" && it.status == DEPLOYED})
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == "Some broken global rules" && it.status == COMPILATION_ERROR})
}
when: "the broken rule definition is removed from the global engine"
@@ -173,12 +173,12 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
then: "the global rules engine should restart"
conditions.eventually {
- assert rulesService.globalEngine.deployments.size() == 2
- assert rulesService.globalEngine.running
- assert !rulesService.globalEngine.isError()
- assert rulesService.globalEngine.error == null
- assert rulesService.globalEngine.deployments.values().any({ it.name == "Some global demo rules" && it.status == DEPLOYED })
- assert rulesService.globalEngine.deployments.values().any({ it.name == "Some more global rules" && it.status == DEPLOYED })
+ assert rulesService.globalEngine.get().deployments.size() == 2
+ assert rulesService.globalEngine.get().running
+ assert !rulesService.globalEngine.get().isError()
+ assert rulesService.globalEngine.get().error == null
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == "Some global demo rules" && it.status == DEPLOYED })
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == "Some more global rules" && it.status == DEPLOYED })
}
when: "a realm is disabled"
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesFactsTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesFactsTest.groovy
index e85428a18..8b887cdc3 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesFactsTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesFactsTest.groovy
@@ -70,7 +70,6 @@ class BasicRulesFactsTest extends Specification {
then: "facts should be present"
assert rulesFacts.allFacts.count() == 3
assert rulesFacts.assetStates.size() == 0
- assert rulesFacts.assetEvents.size() == 0
assert rulesFacts.namedFacts.size() == 3
assert rulesFacts.anonymousFacts.size() == 0
assert rulesFacts.vars.size() == 0
@@ -117,7 +116,6 @@ class BasicRulesFactsTest extends Specification {
then: "facts should be present"
assert rulesFacts.allFacts.count() == 3
assert rulesFacts.assetStates.size() == 0
- assert rulesFacts.assetEvents.size() == 0
assert rulesFacts.namedFacts.size() == 0
assert rulesFacts.anonymousFacts.size() == 3
assert rulesFacts.vars.size() == 0
@@ -171,7 +169,6 @@ class BasicRulesFactsTest extends Specification {
then: "facts should be present"
assert rulesFacts.allFacts.count() == 5
assert rulesFacts.assetStates.size() == 0
- assert rulesFacts.assetEvents.size() == 0
assert rulesFacts.namedFacts.size() == 0
assert rulesFacts.anonymousFacts.size() == 5
assert rulesFacts.vars.size() == 0
@@ -189,7 +186,6 @@ class BasicRulesFactsTest extends Specification {
then: "updated facts should be present"
assert rulesFacts.allFacts.count() == 5
assert rulesFacts.assetStates.size() == 0
- assert rulesFacts.assetEvents.size() == 0
assert rulesFacts.namedFacts.size() == 0
assert rulesFacts.anonymousFacts.size() == 5
assert rulesFacts.vars.size() == 0
@@ -231,7 +227,6 @@ class BasicRulesFactsTest extends Specification {
then: "facts should be present"
assert rulesFacts.allFacts.count() == 6
assert rulesFacts.assetStates.size() == 0
- assert rulesFacts.assetEvents.size() == 0
assert rulesFacts.namedFacts.size() == 3
assert rulesFacts.anonymousFacts.size() == 3
assert rulesFacts.vars.size() == 0
@@ -248,7 +243,6 @@ class BasicRulesFactsTest extends Specification {
then: "updated facts should be present"
assert rulesFacts.allFacts.count() == 6
assert rulesFacts.assetStates.size() == 0
- assert rulesFacts.assetEvents.size() == 0
assert rulesFacts.namedFacts.size() == 3
assert rulesFacts.anonymousFacts.size() == 3
assert rulesFacts.vars.size() == 0
@@ -267,7 +261,6 @@ class BasicRulesFactsTest extends Specification {
then: "updated facts should be present"
assert rulesFacts.allFacts.count() == 5
assert rulesFacts.assetStates.size() == 0
- assert rulesFacts.assetEvents.size() == 0
assert rulesFacts.namedFacts.size() == 3
assert rulesFacts.anonymousFacts.size() == 2
assert rulesFacts.vars.size() == 0
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy
index 7cd4b87b8..11e191284 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesImport.groovy
@@ -97,7 +97,7 @@ class BasicRulesImport {
KeycloakTestSetup keycloakTestSetup,
ManagerTestSetup managerTestSetup) {
- globalEngine = rulesService.globalEngine
+ globalEngine = rulesService.globalEngine.get()
assert globalEngine != null
assert globalEngine.isRunning()
assert globalEngine.deployments.size() == 1
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy
index 6f9291a5e..4c5ffe0d0 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesProcessingTest.groovy
@@ -72,7 +72,7 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
and: "the new rule engine is fully initialised"
conditions.eventually {
- assert smartHomeEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert smartHomeEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
assertRulesFired(rulesImport.globalEngine, 1)
assertRulesFired(rulesImport.globalEngine, ["All"])
assertRulesFired(rulesImport.realmBuildingEngine, 1)
@@ -151,11 +151,11 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
then: "after a few seconds the engines in scope should have facts and rules should have fired"
conditions.eventually {
assert rulesService.attributeEvents.size() == DEMO_RULE_STATES_GLOBAL + 1
- assert rulesImport.globalEngine.assetStates.size() == DEMO_RULE_STATES_GLOBAL + 1
- assert rulesImport.masterEngine.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
- assert rulesImport.realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING + 1
- assert rulesImport.apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2 + 1
- assert rulesImport.apartment3Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
+ assert rulesImport.globalEngine.facts.assetStates.size() == DEMO_RULE_STATES_GLOBAL + 1
+ assert rulesImport.masterEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
+ assert rulesImport.realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING + 1
+ assert rulesImport.apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2 + 1
+ assert rulesImport.apartment3Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
assertRulesFired(rulesImport.globalEngine, 1)
assertRulesFired(rulesImport.globalEngine, ["All"])
assertRulesFired(rulesImport.masterEngine, 1)
@@ -197,11 +197,11 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
then: "no rules should have fired"
conditions.eventually {
assert rulesService.attributeEvents.size() == DEMO_RULE_STATES_GLOBAL + 1
- assert rulesImport.globalEngine.assetStates.size() == DEMO_RULE_STATES_GLOBAL + 1
- assert rulesImport.masterEngine.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
- assert rulesImport.realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING + 1
- assert rulesImport.apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2 + 1
- assert rulesImport.apartment3Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
+ assert rulesImport.globalEngine.facts.assetStates.size() == DEMO_RULE_STATES_GLOBAL + 1
+ assert rulesImport.masterEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
+ assert rulesImport.realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING + 1
+ assert rulesImport.apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2 + 1
+ assert rulesImport.apartment3Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
assertRulesFired(rulesImport.globalEngine, 1)
assertRulesFired(rulesImport.masterEngine, 1)
assertRulesFired(rulesImport.realmBuildingEngine, 1)
@@ -223,11 +223,11 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
then: "the facts should be removed from the rule engines and rules should have fired"
conditions.eventually {
assert rulesService.attributeEvents.size() == DEMO_RULE_STATES_GLOBAL
- assert rulesImport.globalEngine.assetStates.size() == DEMO_RULE_STATES_GLOBAL
- assert rulesImport.masterEngine.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
- assert rulesImport.realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
- assert rulesImport.apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
- assert rulesImport.apartment3Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
+ assert rulesImport.globalEngine.facts.assetStates.size() == DEMO_RULE_STATES_GLOBAL
+ assert rulesImport.masterEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
+ assert rulesImport.realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert rulesImport.apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
+ assert rulesImport.apartment3Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
assertRulesFired(rulesImport.globalEngine, 1)
assertRulesFired(rulesImport.globalEngine, ["All"])
assertRulesFired(rulesImport.realmBuildingEngine, 1)
@@ -254,11 +254,11 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
then: "the facts should be added to the rule engines and rules should have fired"
conditions.eventually {
assert rulesService.attributeEvents.size() == DEMO_RULE_STATES_GLOBAL + 2
- assert rulesImport.globalEngine.assetStates.size() == DEMO_RULE_STATES_GLOBAL + 2
- assert rulesImport.masterEngine.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
- assert rulesImport.realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING + 2
- assert rulesImport.apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2 + 2
- assert rulesImport.apartment3Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
+ assert rulesImport.globalEngine.facts.assetStates.size() == DEMO_RULE_STATES_GLOBAL + 2
+ assert rulesImport.masterEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
+ assert rulesImport.realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING + 2
+ assert rulesImport.apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2 + 2
+ assert rulesImport.apartment3Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
assertRulesFired(rulesImport.globalEngine, 1)
assertRulesFired(rulesImport.globalEngine, ["All"])
assertRulesFired(rulesImport.realmBuildingEngine, 1)
@@ -275,11 +275,11 @@ class BasicRulesProcessingTest extends Specification implements ManagerContainer
then: "the facts should be removed from the rule engines and rules should have fired"
conditions.eventually {
assert rulesService.attributeEvents.size() == DEMO_RULE_STATES_GLOBAL
- assert rulesImport.globalEngine.assetStates.size() == DEMO_RULE_STATES_GLOBAL
- assert rulesImport.masterEngine.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
- assert rulesImport.realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
- assert rulesImport.apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
- assert rulesImport.apartment3Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
+ assert rulesImport.globalEngine.facts.assetStates.size() == DEMO_RULE_STATES_GLOBAL
+ assert rulesImport.masterEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_OFFICE
+ assert rulesImport.realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert rulesImport.apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
+ assert rulesImport.apartment3Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_3
assertRulesFired(rulesImport.globalEngine, 1)
assertRulesFired(rulesImport.globalEngine, ["All"])
assertRulesFired(rulesImport.realmBuildingEngine, 1)
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesTimedExecutionTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesTimedExecutionTest.groovy
index d112c00fd..eebc2f6ac 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesTimedExecutionTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesTimedExecutionTest.groovy
@@ -50,7 +50,7 @@ class BasicRulesTimedExecutionTest extends Specification implements ManagerConta
expect: "the rule engines to become available and be running"
conditions.eventually {
- globalEngine = rulesService.globalEngine
+ globalEngine = rulesService.globalEngine.get()
assert globalEngine != null
assert globalEngine.isRunning()
assert globalEngine.knowledgeSession.factCount == DEMO_RULE_STATES_GLOBAL
@@ -89,7 +89,7 @@ class BasicRulesTimedExecutionTest extends Specification implements ManagerConta
expect: "the rule engines to become available and be running"
conditions.eventually {
- globalEngine = rulesService.globalEngine
+ globalEngine = rulesService.globalEngine.get()
assert globalEngine != null
assert globalEngine.isRunning()
assert globalEngine.knowledgeSession.factCount == DEMO_RULE_STATES_GLOBAL
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
index 46d2ee07e..2d1b18913 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesetResourceTest.groovy
@@ -106,7 +106,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
and: "the ruleset should reach the engine"
conditions.eventually {
- def deployment = rulesService.globalEngine.deployments.get(rulesetId)
+ def deployment = rulesService.globalEngine.get().deployments.get(rulesetId)
assert deployment != null
assert deployment.ruleset.version == globalRuleset.version
}
@@ -127,7 +127,7 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
and: "the ruleset should reach the engine"
conditions.eventually {
- def deployment = rulesService.globalEngine.deployments.get(rulesetId)
+ def deployment = rulesService.globalEngine.get().deployments.get(rulesetId)
assert deployment != null
assert deployment.ruleset.version == globalRuleset.version
}
@@ -142,8 +142,8 @@ class BasicRulesetResourceTest extends Specification implements ManagerContainer
and: "the ruleset should be removed from the engine"
conditions.eventually {
- assert rulesService.globalEngine != null
- def deployment = rulesService.globalEngine.deployments.get(rulesetId)
+ assert rulesService.globalEngine.get() != null
+ def deployment = rulesService.globalEngine.get().deployments.get(rulesetId)
assert deployment == null
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/ChildAssetControlRulesTest.groovy b/test/src/test/groovy/org/openremote/test/rules/ChildAssetControlRulesTest.groovy
index e02c2fe65..b832ccbec 100644
--- a/test/src/test/groovy/org/openremote/test/rules/ChildAssetControlRulesTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/ChildAssetControlRulesTest.groovy
@@ -52,7 +52,7 @@ class ChildAssetControlRulesTest extends Specification implements ManagerContain
lightAsset.getAttribute(LightAsset.BRIGHTNESS).ifPresentOrElse(attr -> {attr.addMeta(new MetaItem<>(MetaItemType.RULE_STATE))}, null)
lightAsset.getAttribute(LightAsset.COLOUR_RGB).ifPresentOrElse(attr -> {attr.addMeta(new MetaItem<>(MetaItemType.RULE_STATE))}, null)
lightAsset.getAttribute(LightAsset.COLOUR_TEMPERATURE).ifPresentOrElse(attr -> {attr.addMeta(new MetaItem<>(MetaItemType.RULE_STATE))}, null)
- assetStorageService.merge(lightAsset)
+ lightAsset = assetStorageService.merge(lightAsset)
}
and: "the child asset control ruleset is added"
@@ -68,7 +68,7 @@ class ChildAssetControlRulesTest extends Specification implements ManagerContain
engine = rulesService.realmEngines.get(Constants.MASTER_REALM)
assert engine != null
assert engine.isRunning()
- assert engine.assetStates.count { it.id == parentAsset.id} == 4
+ assert engine.facts.assetStates.count { it.id == parentAsset.id} == 4
assert engine.lastFireTimestamp > ruleset.createdOn.getTime()
assert engine.deployments.get(ruleset.id) != null
}
@@ -107,7 +107,7 @@ class ChildAssetControlRulesTest extends Specification implements ManagerContain
then: "the child asset states should be loaded into the rule engine"
conditions.eventually {
- assert engine.assetStates.count { it.id == lightAsset.id} == 4
+ assert engine.facts.assetStates.count { it.id == lightAsset.id} == 4
}
when: "the child asset is moved under the group parent"
@@ -116,7 +116,7 @@ class ChildAssetControlRulesTest extends Specification implements ManagerContain
then: "the child asset states should be loaded into the rule engine"
conditions.eventually {
- assert engine.assetStates.count { it.id == lightAsset.id && it.parentId == parentAsset.id} == 4
+ assert engine.facts.assetStates.count { it.id == lightAsset.id && it.parentId == parentAsset.id} == 4
}
when: "The on/off attribute of the parent asset is written to"
diff --git a/test/src/test/groovy/org/openremote/test/rules/GroupSummationRuleTest.groovy b/test/src/test/groovy/org/openremote/test/rules/GroupSummationRuleTest.groovy
index ce07e21cb..596bfa818 100644
--- a/test/src/test/groovy/org/openremote/test/rules/GroupSummationRuleTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/GroupSummationRuleTest.groovy
@@ -76,7 +76,7 @@ class GroupSummationRuleTest extends Specification implements ManagerContainerTr
engine = rulesService.realmEngines.get(Constants.MASTER_REALM)
assert engine != null
assert engine.isRunning()
- assert engine.assetStates.count { it.id == parentAsset.id } == 3
+ assert engine.facts.assetStates.count { it.id == parentAsset.id } == 3
assert engine.lastFireTimestamp > ruleset.createdOn.getTime()
assert engine.deployments.get(ruleset.id) != null
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/FlowRulesTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/FlowRulesTest.groovy
index 02677e8e6..f2c7462c3 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/FlowRulesTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/FlowRulesTest.groovy
@@ -60,9 +60,9 @@ class FlowRulesTest extends Specification implements ManagerContainerTrait {
then: "the flow should be deployed"
conditions.eventually {
- assert rulesService.globalEngine != null
- assert rulesService.globalEngine.isRunning()
- assert rulesService.globalEngine.deployments.values().any({ it.name == realCollection.name && it.status == DEPLOYED})
+ assert rulesService.globalEngine.get() != null
+ assert rulesService.globalEngine.get().isRunning()
+ assert rulesService.globalEngine.get().deployments.values().any({ it.name == realCollection.name && it.status == DEPLOYED})
}
and: "the flow should be executed correctly"
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy
index 7987c9b25..7b1630e74 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/JsonRulesTest.groovy
@@ -175,7 +175,7 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
assert realmBuildingEngine != null
assert realmBuildingEngine.isRunning()
- assert realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
assert realmBuildingEngine.lastFireTimestamp > 0
assert !realmBuildingEngine.trackLocationPredicates
}
@@ -308,7 +308,7 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
then: "the console location asset state should be in the rule engine"
conditions.eventually {
- def assetState = realmBuildingEngine.assetStates.find {it.id == consoleRegistration.id && it.name == Asset.LOCATION.name}
+ def assetState = realmBuildingEngine.facts.assetStates.find {it.id == consoleRegistration.id && it.name == Asset.LOCATION.name}
assert assetState != null
assert assetState.getValue().isPresent()
assert assetState.getValue(GeoJSONPoint.class).map{it.x == ManagerTestSetup.SMART_BUILDING_LOCATION.x}.orElse(false)
@@ -635,7 +635,7 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
assert realmBuildingEngine != null
assert realmBuildingEngine.isRunning()
- assert realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
assert realmBuildingEngine.lastFireTimestamp == timerService.getNow().toEpochMilli()
lastFireTimestamp = realmBuildingEngine.lastFireTimestamp
assert sunsetCalculator != null
@@ -764,7 +764,7 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
assert realmBuildingEngine != null
assert realmBuildingEngine.isRunning()
- assert realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
assert realmBuildingEngine.lastFireTimestamp == timerService.getNow().toEpochMilli()
lastFireTimestamp = realmBuildingEngine.lastFireTimestamp
}
@@ -819,7 +819,7 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
assert realmBuildingEngine != null
assert realmBuildingEngine.isRunning()
- assert realmBuildingEngine.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
+ assert realmBuildingEngine.facts.assetStates.size() == DEMO_RULE_STATES_SMART_BUILDING
assert realmBuildingEngine.lastFireTimestamp == timerService.getNow().toEpochMilli()
lastFireTimestamp = realmBuildingEngine.lastFireTimestamp
}
@@ -909,7 +909,7 @@ class JsonRulesTest extends Specification implements ManagerContainerTrait {
assert realmBuildingEngine.deployments.size() == 1
assert realmBuildingEngine.deployments.values().iterator().next().name == "Webhook Rule"
assert realmBuildingEngine.deployments.values().iterator().next().status == DEPLOYED
- assert realmBuildingEngine.assetStates.size() == (DEMO_RULE_STATES_SMART_BUILDING + 1)
+ assert realmBuildingEngine.facts.assetStates.size() == (DEMO_RULE_STATES_SMART_BUILDING + 1)
assert realmBuildingEngine.lastFireTimestamp > 0
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy
index f7c06678c..d649563a4 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAllLightsOffTest.groovy
@@ -50,7 +50,7 @@ class ResidenceAllLightsOffTest extends Specification implements ManagerContaine
and: "the demo attributes marked with RULE_STATE = true meta should be inserted into the engines"
conditions.eventually {
- assert apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
+ assert apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
}
and: "the room lights in an apartment to be on"
@@ -69,8 +69,8 @@ class ResidenceAllLightsOffTest extends Specification implements ManagerContaine
then: "the room lights in the apartment should be off"
conditions.eventually {
- assert apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
- assert apartment2Engine.assetEvents.size() == 1
+ assert apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
+ assert apartment2Engine.facts.assetEvents.size() == 1
def livingroomAsset = assetStorageService.find(managerTestSetup.apartment2LivingroomId, true)
assert !livingroomAsset.getAttribute("lightSwitch").get().value.get()
def bathRoomAsset = assetStorageService.find(managerTestSetup.apartment2BathroomId, true)
@@ -87,8 +87,8 @@ class ResidenceAllLightsOffTest extends Specification implements ManagerContaine
then: "the light should still be on after a few seconds (the all lights off event expires after 3 seconds)"
new PollingConditions(timeout: 5, initialDelay: 3).eventually {
- assert apartment2Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
- assert apartment2Engine.assetEvents.size() == 0
+ assert apartment2Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_2
+ assert apartment2Engine.facts.assetEvents.size() == 0
def livingroomAsset = assetStorageService.find(managerTestSetup.apartment2LivingroomId, true)
assert livingroomAsset.getAttribute("lightSwitch").get().value.get()
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy
index 6e0fedcb7..b56c6962c 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceAutoVentilationTest.groovy
@@ -51,7 +51,7 @@ class ResidenceAutoVentilationTest extends Specification implements ManagerConta
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "the ventilation should be off"
@@ -84,7 +84,7 @@ class ResidenceAutoVentilationTest extends Specification implements ManagerConta
// Wait for event to be processed
conditions.eventually {
- assert apartment1Engine.assetEvents.any() {
+ assert apartment1Engine.facts.assetEvents.any() {
it.fact.matches(co2LevelIncrement, SENSOR, true)
}
assert noEventProcessedIn(assetProcessingService, 500)
@@ -107,7 +107,7 @@ class ResidenceAutoVentilationTest extends Specification implements ManagerConta
then: "the decreasing CO2 should have been detected in rules"
conditions.eventually {
- assert apartment1Engine.assetEvents.any() {
+ assert apartment1Engine.facts.assetEvents.any() {
it.fact.matches(co2LevelDecrement, SENSOR, true)
}
assert noEventProcessedIn(assetProcessingService, 500)
@@ -133,7 +133,7 @@ class ResidenceAutoVentilationTest extends Specification implements ManagerConta
// Wait for event to be processed
conditions.eventually {
- assert apartment1Engine.assetEvents.any() {
+ assert apartment1Engine.facts.assetEvents.any() {
it.fact.matches(co2LevelIncrement, SENSOR, true)
}
assert noEventProcessedIn(assetProcessingService, 500)
@@ -154,7 +154,7 @@ class ResidenceAutoVentilationTest extends Specification implements ManagerConta
)
simulatorProtocol.putValue(co2LevelDecrement2)
conditions.eventually {
- assert apartment1Engine.assetEvents.any() {
+ assert apartment1Engine.facts.assetEvents.any() {
it.fact.matches(co2LevelDecrement2, SENSOR, true)
}
assert noEventProcessedIn(assetProcessingService, 500)
@@ -175,7 +175,7 @@ class ResidenceAutoVentilationTest extends Specification implements ManagerConta
)
simulatorProtocol.putValue(co2LevelDecrement3)
conditions.eventually {
- assert apartment1Engine.assetEvents.any() {
+ assert apartment1Engine.facts.assetEvents.any() {
it.fact.matches(co2LevelDecrement3, SENSOR, true)
}
assert noEventProcessedIn(assetProcessingService, 500)
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy
index a55e49503..4b0dbaac8 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceNotifyAlarmTriggerTest.groovy
@@ -51,7 +51,7 @@ import static org.openremote.model.util.ValueUtil.parse
class ResidenceNotifyAlarmTriggerTest extends Specification implements ManagerContainerTrait {
def getOccurrenceFromTo(long baseTime, int occurrence) {
- def tomorrowMidnight = LocalDateTime.ofInstant(Instant.ofEpochMilli(baseTime).truncatedTo(ChronoUnit.DAYS).plus(1, ChronoUnit.DAYS), ZoneId.systemDefault())
+ def tomorrowMidnight = Instant.ofEpochMilli(baseTime).truncatedTo(ChronoUnit.DAYS).plus(1, ChronoUnit.DAYS).atZone(ZoneId.systemDefault())
def from = LocalDateTime.of(tomorrowMidnight.get(ChronoField.YEAR), tomorrowMidnight.get(ChronoField.MONTH_OF_YEAR), tomorrowMidnight.get(ChronoField.DAY_OF_MONTH), 6, 0, 0)
from = from.plus(occurrence, ChronoUnit.WEEKS)
def to = from.plus(2, ChronoUnit.HOURS)
@@ -111,7 +111,7 @@ class ResidenceNotifyAlarmTriggerTest extends Specification implements ManagerCo
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "the alarm enabled, presence detected flag of room should not be set"
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy
index f4bf5f6dd..c6b0418fa 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidencePresenceDetectionTest.groovy
@@ -49,7 +49,7 @@ class ResidencePresenceDetectionTest extends Specification implements ManagerCon
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "the presence detected flag and timestamp should not be set"
@@ -179,7 +179,7 @@ class ResidencePresenceDetectionTest extends Specification implements ManagerCon
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "the presence detected flag and timestamp of the room should not be set"
@@ -218,7 +218,7 @@ class ResidencePresenceDetectionTest extends Specification implements ManagerCon
// Wait for event to be processed
conditions.eventually {
- assert apartment1Engine.assetEvents.any() {
+ assert apartment1Engine.facts.assetEvents.any() {
it.fact.matches(co2LevelIncrement, SENSOR, true)
}
assert noEventProcessedIn(assetProcessingService, 500)
@@ -252,7 +252,7 @@ class ResidencePresenceDetectionTest extends Specification implements ManagerCon
// Wait for event to be processed
conditions.eventually {
- assert apartment1Engine.assetEvents.any {
+ assert apartment1Engine.facts.assetEvents.any {
it.fact.matches(co2LevelIncrement, SENSOR, true)
}
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy
index 8e218dd73..d9ef8e8ce 100644
--- a/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/residence/ResidenceSmartSwitchTest.groovy
@@ -48,7 +48,7 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "smart switches should be off"
@@ -174,7 +174,7 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "smart switches should be off"
@@ -268,7 +268,7 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "smart switches should be off"
@@ -386,7 +386,7 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "smart switches should be off"
@@ -481,7 +481,7 @@ class ResidenceSmartSwitchTest extends Specification implements ManagerContainer
apartment1Engine = rulesService.assetEngines.get(managerTestSetup.apartment1Id)
assert apartment1Engine != null
assert apartment1Engine.isRunning()
- assert apartment1Engine.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
+ assert apartment1Engine.facts.assetStates.size() == DEMO_RULE_STATES_APARTMENT_1
}
and: "smart switches should be off"
diff --git a/test/src/test/resources/org/openremote/test/rules/ResidenceSmartSwitch.groovy b/test/src/test/resources/org/openremote/test/rules/ResidenceSmartSwitch.groovy
index 636744162..7ac140a93 100644
--- a/test/src/test/resources/org/openremote/test/rules/ResidenceSmartSwitch.groovy
+++ b/test/src/test/resources/org/openremote/test/rules/ResidenceSmartSwitch.groovy
@@ -149,9 +149,9 @@ rules.add()
// Stop time is start time plus CYCLE_TIME_MILLISECONDS
def stopMilliseconds = startSeconds + CYCLE_TIME_MILLISECONDS
LOG.info("Smart switch mode is ON_AT, enabling actuator with start/stop times " +
- LocalDateTime.ofInstant(Instant.ofEpochMilli(startSeconds), ZoneId.systemDefault()) +
+ Instant.ofEpochMilli(startSeconds).atZone(ZoneId.systemDefault()).toLocalDateTime() +
"/" +
- LocalDateTime.ofInstant(Instant.ofEpochMilli(stopMilliseconds), ZoneId.systemDefault()) +
+ Instant.ofEpochMilli(stopMilliseconds).atZone(ZoneId.systemDefault()).toLocalDateTime() +
": " + beginEnd)
String smartSwitchName = getSmartSwitchName(beginEnd)
facts.updateAssetState(beginEnd.id, "smartSwitch" + SmartSwitchAttribute.StartTime + smartSwitchName, startSeconds)
@@ -199,8 +199,8 @@ rules.add()
// Stop time is user-provided smart switch time (in seconds)
def stopMilliseconds = beginEnd.value.orElse(0l)
LOG.info("Smart switch mode is READY_AT, enabling actuator with start/stop times " +
- LocalDateTime.ofInstant(Instant.ofEpochMilli(startMilliseconds), ZoneId.systemDefault()) + "/" +
- LocalDateTime.ofInstant(Instant.ofEpochMilli(stopMilliseconds), ZoneId.systemDefault()) +
+ Instant.ofEpochMilli(startMilliseconds).atZone(ZoneId.systemDefault()).toLocalDateTime() + "/" +
+ Instant.ofEpochMilli(stopMilliseconds).atZone(ZoneId.systemDefault()).toLocalDateTime() +
": " +
beginEnd)
String smartSwitchName = getSmartSwitchName(beginEnd)
diff --git a/test/src/testFixtures/groovy/org/openremote/test/ContainerTrait.groovy b/test/src/testFixtures/groovy/org/openremote/test/ContainerTrait.groovy
index 5136fd0cf..8b9edd96c 100644
--- a/test/src/testFixtures/groovy/org/openremote/test/ContainerTrait.groovy
+++ b/test/src/testFixtures/groovy/org/openremote/test/ContainerTrait.groovy
@@ -91,7 +91,7 @@ trait ContainerTrait {
def configsMatch = false
def servicesMatch = false
def currentConfig = container.getConfig()
- if (currentConfig == config) {
+ if (Objects.equals(currentConfig, config)) {
configsMatch = true
} else {
if (currentConfig.size() == config.size()) {
@@ -174,11 +174,11 @@ trait ContainerTrait {
rulesetStorageService.delete(RealmRuleset.class, it.id)
}
- def globalEngine = rulesService.globalEngine
+ def globalEngine = rulesService.globalEngine.get()
if (globalEngine != null) {
LOG.info("Purging global engine")
globalEngine.stop()
- rulesService.globalEngine = null
+ rulesService.globalEngine.set(null)
}
def globalRulesets = getRulesets(GlobalRuleset.class)
globalRulesets.forEach{
@@ -259,6 +259,7 @@ trait ContainerTrait {
}
} else {
LOG.info("Request to start container with different config and/or services as already running container so restarting")
+ LOG.info("Current config = ${currentConfig}, new config = ${config}")
stopContainer()
TestFixture.container = null
}
@@ -330,7 +331,7 @@ trait ContainerTrait {
if (rulesService != null) {
LOG.info("Waiting for global rulesets to be deployed")
i=0
- while (i < 100 && TestFixture.globalRulesets.stream().filter { it.enabled }.any { rulesService.globalEngine == null || !rulesService.globalEngine.deployments.containsKey(it.id) }) {
+ while (i < 100 && TestFixture.globalRulesets.stream().filter { it.enabled }.any { rulesService.globalEngine.get() == null || !rulesService.globalEngine.get().deployments.containsKey(it.id) }) {
Thread.sleep(100)
i++
}
diff --git a/test/src/testFixtures/groovy/org/openremote/test/ManagerContainerTrait.groovy b/test/src/testFixtures/groovy/org/openremote/test/ManagerContainerTrait.groovy
index 9fddb2e77..d36b8061f 100644
--- a/test/src/testFixtures/groovy/org/openremote/test/ManagerContainerTrait.groovy
+++ b/test/src/testFixtures/groovy/org/openremote/test/ManagerContainerTrait.groovy
@@ -7,6 +7,7 @@ import org.openremote.container.message.MessageBrokerService
import org.openremote.container.timer.TimerService
import org.openremote.manager.mqtt.MQTTBrokerService
import org.openremote.model.ContainerService
+import org.openremote.model.util.TextUtil
import spock.util.concurrent.PollingConditions
import java.time.Instant
@@ -19,7 +20,6 @@ import static org.openremote.container.web.WebService.OR_WEBSERVER_LISTEN_PORT
import static org.openremote.manager.mqtt.MQTTBrokerService.MQTT_SERVER_LISTEN_HOST
import static org.openremote.manager.rules.RulesService.OR_RULES_MIN_TEMP_FACT_EXPIRATION_MILLIS
import static org.openremote.manager.rules.RulesService.OR_RULES_QUICK_FIRE_MILLIS
-import static org.openremote.model.Container.OR_METRICS_ENABLED
trait ManagerContainerTrait extends ContainerTrait {
@@ -27,15 +27,17 @@ trait ManagerContainerTrait extends ContainerTrait {
if (serverPort == null) {
serverPort = findEphemeralPort()
}
- [
+ def config = [
(OR_WEBSERVER_LISTEN_PORT): Integer.toString(serverPort),
(MQTT_SERVER_LISTEN_HOST) : "127.0.0.1", // Works best for cross platform test running,
(MQTTBrokerService.MQTT_FORCE_USER_DISCONNECT_DEBOUNCE_MILLIS): "10",
(OR_RULES_QUICK_FIRE_MILLIS): "500",
(OR_RULES_MIN_TEMP_FACT_EXPIRATION_MILLIS): "500",
- (TIMER_CLOCK_TYPE) : PSEUDO.name(),
- (OR_METRICS_ENABLED): "false"
- ]
+ (TIMER_CLOCK_TYPE) : PSEUDO.name()
+ ] << System.getenv()
+
+ config.values().removeIf { TextUtil.isNullOrEmpty(it)}
+ return config
}
Iterable<ContainerService> defaultServices(Iterable<ContainerService> additionalServices) {
diff --git a/ui/component/core/src/asset-mixin.ts b/ui/component/core/src/asset-mixin.ts
index c82ea4766..609afcd48 100644
--- a/ui/component/core/src/asset-mixin.ts
+++ b/ui/component/core/src/asset-mixin.ts
@@ -1,6 +1,6 @@
import {EventProviderFactory, EventProviderStatus} from "./event";
import {objectsEqual} from "./util";
-import {AttributeRef, SharedEvent, EventRequestResponseWrapper} from "@openremote/model";
+import {AttributeRef, SharedEvent} from "@openremote/model";
import { Util } from ".";
declare type Constructor<T = {}> = new (...args: any[]) => T;
@@ -178,7 +178,7 @@ export const subscribe = (eventProviderFactory: EventProviderFactory) => <T exte
eventProviderFactory.getEventProvider()!.sendEvent(event);
}
- public _sendEventWithReply<U extends SharedEvent, V extends SharedEvent>(event: EventRequestResponseWrapper<U>): Promise<V> {
+ public _sendEventWithReply<U extends SharedEvent, V extends SharedEvent>(event: U): Promise<V> {
return eventProviderFactory.getEventProvider()!.sendEventWithReply(event);
}
diff --git a/ui/component/core/src/event.ts b/ui/component/core/src/event.ts
index 1eef9c146..64644b5b9 100644
--- a/ui/component/core/src/event.ts
+++ b/ui/component/core/src/event.ts
@@ -9,7 +9,6 @@ import {
AttributeEvent,
AttributeRef,
CancelEventSubscription,
- EventRequestResponseWrapper,
EventSubscription,
ReadAssetsEvent,
SharedEvent,
@@ -50,7 +49,7 @@ export interface EventProvider {
sendEvent<T extends SharedEvent>(event: T): void;
- sendEventWithReply<T extends SharedEvent, U extends SharedEvent>(event: EventRequestResponseWrapper<T>): Promise<U>;
+ sendEventWithReply<T extends SharedEvent, U extends SharedEvent>(event: T): Promise<U>;
}
// Interface to provide a singleton implementation of EventProvider
@@ -76,7 +75,6 @@ const UNSUBSCRIBE_MESSAGE_PREFIX = "UNSUBSCRIBE:";
const UNAUTHORIZED_MESSAGE_PREFIX = "UNAUTHORIZED:";
const TRIGGERED_MESSAGE_PREFIX = "TRIGGERED:";
const EVENT_MESSAGE_PREFIX = "EVENT:";
-const EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX = "REQUESTRESPONSE:";
abstract class EventProviderImpl implements EventProvider {
@@ -260,7 +258,7 @@ abstract class EventProviderImpl implements EventProvider {
}
}
- public sendEventWithReply<T extends SharedEvent, U extends SharedEvent>(event: EventRequestResponseWrapper<T>): Promise<U> {
+ public sendEventWithReply<T extends SharedEvent, U extends SharedEvent>(event: T): Promise<U> {
if (this._status !== EventProviderStatus.CONNECTED) {
return Promise.reject("Not connected");
}
@@ -323,13 +321,11 @@ abstract class EventProviderImpl implements EventProvider {
try {
// Get the current state of the assets if requested
if (assetIds && requestCurrentValues) {
- const readRequest: EventRequestResponseWrapper<ReadAssetsEvent> = {
- messageId: "read-assets:" + assetIds.join(",") + ":" + subscriptionId,
- event: {
- eventType: "read-assets",
- assetQuery: {
- ids: assetIds
- }
+ const readRequest: ReadAssetsEvent = {
+ messageID: "read-assets:" + assetIds.join(",") + ":" + subscriptionId,
+ eventType: "read-assets",
+ assetQuery: {
+ ids: assetIds
}
}
this.sendEventWithReply(readRequest)
@@ -421,13 +417,11 @@ abstract class EventProviderImpl implements EventProvider {
// Get the current state of the attributes if requested
if (requestCurrentValues && assetIds) {
// Just request the whole asset(s) and let the event filter do the work
- const readRequest: EventRequestResponseWrapper<ReadAssetsEvent> = {
- messageId: "read-assets:" + assetIds.join(",") + ":" + subscriptionId,
- event: {
- eventType: "read-assets",
- assetQuery: {
- ids: assetIds
- }
+ const readRequest: ReadAssetsEvent = {
+ messageID: "read-assets:" + assetIds.join(",") + ":" + subscriptionId,
+ eventType: "read-assets",
+ assetQuery: {
+ ids: assetIds
}
}
this.sendEventWithReply(readRequest)
@@ -574,7 +568,7 @@ abstract class EventProviderImpl implements EventProvider {
protected abstract _doSend<T extends SharedEvent>(event: T): void;
- protected abstract _doSendWithReply<T extends SharedEvent, U extends SharedEvent>(event: EventRequestResponseWrapper<T>): Promise<U>;
+ protected abstract _doSendWithReply<T extends SharedEvent, U extends SharedEvent>(event: T): Promise<U>;
protected abstract _doConnect(): Promise<boolean>;
@@ -681,14 +675,14 @@ export class WebSocketEventProvider extends EventProviderImpl {
this._onMessageReceived(triggered.subscriptionId!, event);
});
}
- } else if (msg.startsWith(EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX)) {
- const str = msg.substring(EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX.length);
- const event = JSON.parse(str) as EventRequestResponseWrapper<SharedEvent>;
- if (event.messageId && event.event) {
- const deferred = this._repliesDeferred.get(event.messageId!);
- this._repliesDeferred.delete(event.messageId!);
+ } else if (msg.startsWith(EVENT_MESSAGE_PREFIX)) {
+ const str = msg.substring(EVENT_MESSAGE_PREFIX.length);
+ const event = JSON.parse(str) as SharedEvent;
+ if (event.messageID) {
+ const deferred = this._repliesDeferred.get(event.messageID!);
+ this._repliesDeferred.delete(event.messageID!);
if (deferred) {
- deferred.resolve(event.event);
+ deferred.resolve(event);
}
}
}
@@ -739,19 +733,19 @@ export class WebSocketEventProvider extends EventProviderImpl {
this._webSocket!.send(message);
}
- protected _doSendWithReply<T extends SharedEvent, U extends SharedEvent>(event: EventRequestResponseWrapper<T>): Promise<U> {
+ protected _doSendWithReply<T extends SharedEvent, U extends SharedEvent>(event: T): Promise<U> {
- if (!event.messageId) {
- event.messageId = (new Date().getTime() + (Math.random() * 10)).toString(10);
+ if (!event.messageID) {
+ event.messageID = (new Date().getTime() + (Math.random() * 10)).toString(10);
}
- if (this._repliesDeferred.has(event.messageId)) {
+ if (this._repliesDeferred.has(event.messageID)) {
return Promise.reject("There's already a pending send and reply with this ID");
}
const deferred = new Deferred<SharedEvent>();
- this._repliesDeferred.set(event.messageId, deferred);
- this._webSocket!.send(EVENT_REQUEST_RESPONSE_MESSAGE_PREFIX + JSON.stringify(event));
+ this._repliesDeferred.set(event.messageID, deferred);
+ this._webSocket!.send(EVENT_MESSAGE_PREFIX + JSON.stringify(event));
return (deferred as unknown as Deferred<U>).promise;
}
}
diff --git a/ui/component/or-asset-tree/src/index.ts b/ui/component/or-asset-tree/src/index.ts
index d58227332..a9b3dba40 100644
--- a/ui/component/or-asset-tree/src/index.ts
+++ b/ui/component/or-asset-tree/src/index.ts
@@ -20,7 +20,7 @@ import {
LogicGroup,
LogicGroupOperator,
SharedEvent,
- StringPredicate
+ StringPredicate, WellknownAssets
} from "@openremote/model";
import "@openremote/or-translate";
import {style} from "./style";
@@ -446,6 +446,9 @@ export class OrAssetTree extends subscribe(manager)(LitElement) {
}
protected render() {
+
+ const canAdd = this._canAdd();
+
return html`
<div id="header">
<div id="title-container">
@@ -454,9 +457,9 @@ export class OrAssetTree extends subscribe(manager)(LitElement) {
<div id="header-btns">
<or-mwc-input ?hidden="${!this.selectedIds || this.selectedIds.length === 0 || !this.showDeselectBtn}" type="${InputType.BUTTON}" icon="close" @or-mwc-input-changed="${() => this._onDeselectClicked()}"></or-mwc-input>
- <or-mwc-input ?hidden="${this._isReadonly() || !this.selectedIds || this.selectedIds.length !== 1}" type="${InputType.BUTTON}" icon="content-copy" @or-mwc-input-changed="${() => this._onCopyClicked()}"></or-mwc-input>
- <or-mwc-input ?hidden="${this._isReadonly() || !this.selectedIds || this.selectedIds.length === 0}" type="${InputType.BUTTON}" icon="delete" @or-mwc-input-changed="${() => this._onDeleteClicked()}"></or-mwc-input>
- <or-mwc-input ?hidden="${this._isReadonly() || !this._canAdd()}" type="${InputType.BUTTON}" icon="plus" @or-mwc-input-changed="${() => this._onAddClicked()}"></or-mwc-input>
+ <or-mwc-input ?hidden="${this._isReadonly() || !this.selectedIds || this.selectedIds.length !== 1 || !canAdd}" type="${InputType.BUTTON}" icon="content-copy" @or-mwc-input-changed="${() => this._onCopyClicked()}"></or-mwc-input>
+ <or-mwc-input ?hidden="${this._isReadonly() || !this.selectedIds || this.selectedIds.length === 0 || this._gatewayDescendantIsSelected()}" type="${InputType.BUTTON}" icon="delete" @or-mwc-input-changed="${() => this._onDeleteClicked()}"></or-mwc-input>
+ <or-mwc-input ?hidden="${this._isReadonly() || !canAdd}" type="${InputType.BUTTON}" icon="plus" @or-mwc-input-changed="${() => this._onAddClicked()}"></or-mwc-input>
${getContentWithMenuTemplate(
html`<or-mwc-input type="${InputType.BUTTON}" ?hidden="${!this.showSortBtn}" icon="sort-variant"></or-mwc-input>`,
@@ -1470,6 +1473,19 @@ export class OrAssetTree extends subscribe(manager)(LitElement) {
);
}
+ protected _gatewayDescendantIsSelected(): boolean {
+ return this._selectedNodes.some((n) => {
+ let parentNode = n?.parent;
+ while (parentNode) {
+ if (parentNode.asset?.type === WellknownAssets.GATEWAYASSET) {
+ return true;
+ }
+ parentNode = parentNode.parent;
+ }
+ return false;
+ });
+ }
+
protected _onDeleteClicked() {
if (this._selectedNodes.length > 0) {
Util.dispatchCancellableEvent(this, new OrAssetTreeRequestDeleteEvent(this._selectedNodes))
@@ -1491,10 +1507,34 @@ export class OrAssetTree extends subscribe(manager)(LitElement) {
return;
}
- // Get all unique descendant IDs of selected nodes
- let uniqueAssets = new Set<Asset>();
- OrAssetTree._forEachNodeRecursive(this._selectedNodes, (node) => {
- uniqueAssets.add(node.asset!);
+ const uniqueAssets = new Set<Asset>();
+
+ // Add gateway nodes first
+ const nodes = this._selectedNodes.filter((node) => {
+ if (node.asset?.type === WellknownAssets.GATEWAYASSET) {
+ // Add gateway straight to the unique list and don't recursively select children
+ uniqueAssets.add(node.asset!);
+ return false;
+ }
+ return true;
+ })
+
+ // Iterate through descendants of selected nodes that aren't gateways
+ // and add to delete list (don't recurse descendant gateway nodes)
+ OrAssetTree._forEachNodeRecursive(nodes, (node) => {
+ // Check no ancestor is of type gateway
+ let ancestor = node.parent;
+ let okToAdd = true;
+ while (ancestor && okToAdd) {
+ const ancestorType = ancestor?.asset?.type;
+ if (ancestorType === WellknownAssets.GATEWAYASSET) {
+ okToAdd = false;
+ }
+ ancestor = ancestor.parent;
+ }
+ if (okToAdd) {
+ uniqueAssets.add(node.asset!);
+ }
});
const assetIds: string[] = Array.from(uniqueAssets).map(asset => asset.id!);
const assetNames: string[] = Array.from(uniqueAssets).map(asset => asset.name!);
@@ -1535,6 +1575,16 @@ export class OrAssetTree extends subscribe(manager)(LitElement) {
return false;
}
const selectedNode = this._selectedNodes ? this._selectedNodes[0] : undefined;
+
+ if (selectedNode?.asset?.type === WellknownAssets.GATEWAYASSET) {
+ // Cannot add to a gateway asset
+ return false;
+ }
+
+ if (this._gatewayDescendantIsSelected()) {
+ // Cannot add to a descendant of a gateway asset
+ return false;
+ }
return this._getAllowedChildTypes(selectedNode).length > 0;
}
@@ -1628,10 +1678,8 @@ export class OrAssetTree extends subscribe(manager)(LitElement) {
query.recursive = true;
}
this._sendEventWithReply({
- event: {
- eventType: "read-assets",
- assetQuery: query
- }
+ eventType: "read-assets",
+ assetQuery: query
}).then((ev) => {
this._loading = false;
this._buildTreeNodes((ev as AssetsEvent).assets!, sortFunction)
diff --git a/ui/component/or-attribute-card/src/index.ts b/ui/component/or-attribute-card/src/index.ts
index 1a1547d45..7ffba516a 100644
--- a/ui/component/or-attribute-card/src/index.ts
+++ b/ui/component/or-attribute-card/src/index.ts
@@ -519,10 +519,8 @@ export class OrAttributeCard extends LitElement {
} else {
// fully load the asset
const assetEvent: AssetEvent = await manager.events!.sendEventWithReply({
- event: {
- eventType: "read-asset",
- assetId: selectedNode.asset!.id
- }
+ eventType: "read-asset",
+ assetId: selectedNode.asset!.id
});
this.asset = assetEvent.asset;
}
@@ -728,14 +726,12 @@ export class OrAttributeCard extends LitElement {
const attributeName = this.assetAttributes[0][1].name!;
const currentValue: AttributeEvent = await manager.events!.sendEventWithReply({
- event: {
- eventType: "read-asset-attribute",
- ref: {
- id: assetId,
- name: attributeName
- }
- } as ReadAttributeEvent
- });
+ eventType: "read-asset-attribute",
+ ref: {
+ id: assetId,
+ name: attributeName
+ }
+ } as ReadAttributeEvent);
this.mainValue = currentValue.value;
this.formattedMainValue = this.getFormattedValue(this.mainValue!);
diff --git a/ui/component/or-chart/src/index.ts b/ui/component/or-chart/src/index.ts
index aa87d9a0c..80657bac0 100644
--- a/ui/component/or-chart/src/index.ts
+++ b/ui/component/or-chart/src/index.ts
@@ -744,11 +744,9 @@ export class OrChart extends translate(i18next)(LitElement) {
} else {
// fully load the asset
const assetEvent: AssetEvent = await manager.events.sendEventWithReply({
- event: {
- eventType: "read-asset",
- assetId: selectedNode.asset!.id
- } as ReadAssetEvent
- });
+ eventType: "read-asset",
+ assetId: selectedNode.asset!.id
+ } as ReadAssetEvent);
this.activeAsset = assetEvent.asset;
}
}