openhab-scripting 4.46.2 → 5.0.0

data/lib/openhab/dsl/rules/triggers/updated.rb

@@ -1,44 +1,16 @@
 # frozen_string_literal: true
 
-require 'openhab/log/logger'
-require_relative 'trigger'
+require_relative "trigger"
 
 module OpenHAB
   module DSL
     module Rules
-      #
-      # Module holds rule triggers
-      #
       module Triggers
-        include OpenHAB::Log
-
-        #
-        # Create a trigger when item, group or thing is updated
-        #
-        # @param [Array] items array to trigger on updated
-        # @param [State] to to match for tigger
-        # @param [Object] attach object to be attached to the trigger
-        #
-        # @return [Trigger] Trigger for updated entity
-        #
-        def updated(*items, to: nil, attach: nil)
-          updated = Updated.new(rule_triggers: @rule_triggers)
-          flattened_items = Updated.flatten_items(items)
-          @ruby_triggers << [:updated, flattened_items, { to: to }]
-          flattened_items.map do |item|
-            logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
-            [to].flatten.map do |to_state|
-              updated.trigger(item: item, to: to_state, attach: attach)
-            end
-          end.flatten
-        end
-
+        # @!visibility private
         #
         # Creates updated triggers
         #
         class Updated < Trigger
-          include OpenHAB::Log
-
           #
           # Create the trigger
           #
@@ -46,7 +18,7 @@ module OpenHAB
           # @param [Item State] to state to restrict trigger to
           # @param [Object] attach object to be attached to the trigger
           #
-          # @return [Trigger] OpenHAB triggers
+          # @return [org.openhab.core.automation.Trigger]
           #
           def trigger(item:, to:, attach:)
             case to
@@ -59,20 +31,20 @@ module OpenHAB
           private
 
           # @return [String] A thing status update trigger
-          THING_UPDATE = 'core.ThingStatusUpdateTrigger'
+          THING_UPDATE = "core.ThingStatusUpdateTrigger"
 
           # @return [String] An item state update trigger
-          ITEM_STATE_UPDATE = 'core.ItemStateUpdateTrigger'
+          ITEM_STATE_UPDATE = "core.ItemStateUpdateTrigger"
 
           # @return [String] A group state update trigger for items in the group
-          GROUP_STATE_UPDATE = 'core.GroupStateUpdateTrigger'
+          GROUP_STATE_UPDATE = "core.GroupStateUpdateTrigger"
 
           #
           # Creates a trigger with a range condition on the 'to' field
           # @param [Object] item to create changed trigger on
           # @param [Object] to state restrict trigger to
           # @param [Object] attach object to be attached to the trigger
-          # @return [Trigger] OpenHAB trigger
+          # @return [org.openhab.core.automation.Trigger]
           #
           def range_trigger(item:, to:, attach:)
             to, * = Conditions::Proc.range_procs(to)
@@ -84,7 +56,7 @@ module OpenHAB
           # @param [Object] item to create changed trigger on
           # @param [Object] to state restrict trigger to
           # @param [Object] attach object to be attached to the trigger
-          # @return [Trigger] OpenHAB trigger
+          # @return [org.openhab.core.automation.Trigger]
           #
           def proc_trigger(item:, to:, attach:)
             conditions = Conditions::Proc.new(to: to)
@@ -98,13 +70,17 @@ module OpenHAB
           # @param [State] to state restriction on trigger
           # @param [Object] attach object to be attached to the trigger
           #
-          # @return [Trigger] OpenHAB triggers
+          # @return [org.openhab.core.automation.Trigger]
           #
           def update_trigger(item:, to:, attach: nil, conditions: nil)
             type, config = case item
-                           when OpenHAB::DSL::Items::GroupItem::GroupMembers then group_update(item: item, to: to)
-                           when Thing then thing_update(thing: item, to: to)
-                           else item_update(item: item, to: to)
+                           when GroupItem::Members
+                             group_update(item: item, to: to)
+                           when Core::Things::Thing,
+                                Core::Things::ThingUID
+                             thing_update(thing: item, to: to)
+                           else
+                             item_update(item: item, to: to)
                            end
             append_trigger(type: type, config: config, attach: attach, conditions: conditions)
           end
@@ -119,23 +95,23 @@ module OpenHAB
           #  second element is a Hash configuring trigger
           #
           def item_update(item:, to:)
-            config = { 'itemName' => item.name }
-            config['state'] = to.to_s unless to.nil?
+            config = { "itemName" => item.name }
+            config["state"] = to.to_s unless to.nil?
             [ITEM_STATE_UPDATE, config]
           end
 
           #
           # Create an update trigger for a group
           #
-          # @param [Item] item to create trigger for
+          # @param [GroupItem::Members] item to create trigger for
           # @param [State] to optional state restriction for target
           #
           # @return [Array<Hash,String>] first element is a String specifying trigger type
           #  second element is a Hash configuring trigger
           #
           def group_update(item:, to:)
-            config = { 'groupName' => item.group.name }
-            config['state'] = to.to_s unless to.nil?
+            config = { "groupName" => item.group.name }
+            config["state"] = to.to_s unless to.nil?
             [GROUP_STATE_UPDATE, config]
           end
 

data/lib/openhab/dsl/rules/triggers/watch/watch_handler.rb

@@ -1,126 +1,278 @@
 # frozen_string_literal: true
 
-require 'java'
-require 'openhab/log/logger'
-require 'openhab/core/services'
+require "singleton"
+require "pathname"
+require "securerandom"
 
 module OpenHAB
   module DSL
     module Rules
-      #
-      # Module holds rule triggers
-      #
       module Triggers
+        # @!visibility private
         #
         # Module for watching directories/files
         #
         module WatchHandler
-          include OpenHAB::Log
-
-          #
-          # Creates trigger types and trigger type factories for OpenHAB
-          #
-          private_class_method def self.watch_trigger_type
-            TriggerType.new(
-              WATCH_TRIGGER_MODULE_ID,
-              nil,
-              'A path change event is detected',
-              'Triggers when a path change event is detected',
-              nil,
-              org.openhab.core.automation.Visibility::VISIBLE,
-              nil
-            )
+          # Trigger ID for Watch Triggers
+          WATCH_TRIGGER_MODULE_ID = "jsr223.jruby.WatchTrigger"
+
+          # WatchService is only available in openHAB4
+          def self.factory
+            @factory ||= OSGi.service("org.openhab.core.service.WatchServiceFactory")
           end
 
-          # Struct for Watch Events
-          WatchEvent = Struct.new(:type, :path, :attachment)
+          # Due to the refactoring in OH4, we need a different watcher implementation
+          if WatchHandler.factory
+            # A class that implements openHAB4's WatchEventListener
+            # and also creates and removes a unique WatchService for each instance
+            class Watcher
+              # Use full java class name here to satisfy YARD linter
+              include org.openhab.core.service.WatchService::WatchEventListener
+              java_import org.openhab.core.service.WatchService
 
-          # Trigger ID for Watch Triggers
-          WATCH_TRIGGER_MODULE_ID = 'jsr223.jruby.WatchTrigger'
-
-          # Extends the OpenHAB watch service to watch directories
-          #
-          # Must match java method name style
-          # rubocop:disable Naming/MethodName
-          class Watcher < org.openhab.core.service.AbstractWatchService
-            java_import java.nio.file.StandardWatchEventKinds
-
-            # Hash of event symbols as strings to map to NIO events
-            STRING_TO_EVENT = {
-              created: StandardWatchEventKinds::ENTRY_CREATE,
-              deleted: StandardWatchEventKinds::ENTRY_DELETE,
-              modified: StandardWatchEventKinds::ENTRY_MODIFY
-            }.transform_keys(&:to_s).freeze
-
-            # Hash of NIO event kinds to ruby symbols
-            EVENT_TO_SYMBOL = STRING_TO_EVENT.invert.transform_values(&:to_sym).freeze
-
-            # Creates a new Watch Service
-            def initialize(path, types, &block)
-              super(path)
-              @types = types.map { |type| STRING_TO_EVENT[type] }
-              @block = block
-            end
+              # Hash of event symbols as strings to map to WatchService events
+              STRING_TO_EVENT = {
+                created: WatchService::Kind::CREATE,
+                deleted: WatchService::Kind::DELETE,
+                modified: WatchService::Kind::MODIFY
+              }.transform_keys(&:to_s).freeze
 
-            # Invoked by java super class to get type of events to watch for
-            # @param [String] _path ignored
-            #
-            # @return [Array] array of NIO event kinds
-            def getWatchEventKinds(_path)
-              @types
-            end
+              # Hash of WatchService event kinds to ruby symbols
+              EVENT_TO_SYMBOL = STRING_TO_EVENT.invert.transform_values(&:to_sym).freeze
 
-            # Invoked by java super class to check if sub directories should be watched
-            # @return [false] false
-            def watchSubDirectories
-              false
+              # constructor
+              def initialize(path, subdirs, types, &block)
+                @types = types.map { |type| STRING_TO_EVENT[type] }
+                @block = block
+                @subdirs = subdirs
+                @path = Pathname.new(path)
+                return if path.to_s.start_with?(OpenHAB::Core.config_folder.to_s)
+
+                @custom_watcher = "jrubyscripting-#{SecureRandom.uuid}"
+              end
+
+              # Creates a new Watch Service and registers ourself as a listener
+              # This isn't an OSGi service, but it's called by {WatchTriggerHandler} below.
+              def activate
+                java_path = java.nio.file.Path.of(@path.to_s)
+
+                service_name = WatchService::SERVICE_PID
+                filter = if @custom_watcher
+                           WatchHandler.factory.create_watch_service(@custom_watcher, java_path)
+                           logger.trace { "Created a watch service #{@custom_watcher} for #{@path}" }
+                           "(name=#{@custom_watcher})"
+                         else
+                           logger.trace { "Using configWatcher service for #{@path}" }
+                           WatchService::CONFIG_WATCHER_FILTER
+                         end
+
+                start = Time.now
+                sleep 0.1 until (@watch_service = OSGi.service(service_name, filter: filter)) || Time.now - start > 2
+
+                unless @watch_service
+                  logger.warn("Watch service is not ready in time. #{@path} will not be monitored!")
+                  return
+                end
+
+                @watch_service.register_listener(self, java_path, @subdirs)
+                logger.trace { "Registered watch service listener for #{@path} including subdirs: #{@subdirs}" }
+              end
+
+              # Unregister ourself as a listener and remove the watch service
+              def deactivate
+                @watch_service&.unregister_listener(self)
+                return unless @custom_watcher
+
+                WatchHandler.factory.remove_watch_service(@custom_watcher)
+                logger.trace { "Removed watch service #{@custom_watcher} for #{@path}" }
+              end
+
+              # Invoked by the WatchService when a watch event occurs
+              # @param [org.openhab.core.service.WatchService.Kind] kind WatchService event kind
+              # @param [java.nio.file.Path] path The path that had an event
+              def processWatchEvent(kind, path) # rubocop:disable Naming/MethodName
+                logger.trace { "processWatchEvent triggered #{path} #{kind} #{@types}" }
+                return unless @types.include?(kind)
+
+                # OH4 WatchService feeds us a relative path,
+                # but just in case its implementation changes in the future
+                path = path.absolute? ? Pathname.new(path.to_s) : @path + path.to_s
+                @block.call(Events::WatchEvent.new(EVENT_TO_SYMBOL[kind], path))
+              end
             end
+          else
+            # @deprecated OH3.4
+            #
+            # Extends the openHAB3 watch service to watch directories
+            #
+            # Must match java method name style
+            # rubocop:disable Naming/MethodName
+            class Watcher < org.openhab.core.service.AbstractWatchService
+              java_import java.nio.file.StandardWatchEventKinds
+
+              # Hash of event symbols as strings to map to NIO events
+              STRING_TO_EVENT = {
+                created: StandardWatchEventKinds::ENTRY_CREATE,
+                deleted: StandardWatchEventKinds::ENTRY_DELETE,
+                modified: StandardWatchEventKinds::ENTRY_MODIFY
+              }.transform_keys(&:to_s).freeze
+
+              # Hash of NIO event kinds to ruby symbols
+              EVENT_TO_SYMBOL = STRING_TO_EVENT.invert.transform_values(&:to_sym).freeze
+
+              # Creates a new Watch Service
+              def initialize(path, subdirs, types, &block)
+                super(path)
+                @types = types.map { |type| STRING_TO_EVENT[type] }
+                @block = block
+                @subdirs = subdirs
+              end
 
-            # Invoked by java super class when an watch event occurs
-            # @param [String] _event ignored
-            # @param [StandardWatchEventKind] kind NIO watch event kind
-            # @param [java.nio.Path] path that had an event
-            def processWatchEvent(_event, kind, path)
-              @block.call(WatchEvent.new(EVENT_TO_SYMBOL[kind], Pathname.new(path.to_s)))
+              # Invoked by java super class to get type of events to watch for
+              # @param [String] _path ignored
+              #
+              # @return [Array] array of NIO event kinds
+              def getWatchEventKinds(_path)
+                @types
+              end
+
+              # Invoked by java super class to check if sub directories should be watched
+              # @return [false] false
+              def watchSubDirectories
+                logger.trace("watchSubDirectories returning #{@subdirs}")
+                @subdirs
+              end
+
+              # Invoked by java super class when a watch event occurs
+              # @param [String] _event ignored
+              # @param [StandardWatchEventKind] kind NIO watch event kind
+              # @param [java.nio.file.Path] path that had an event
+              def processWatchEvent(_event, kind, path)
+                @block.call(Events::WatchEvent.new(EVENT_TO_SYMBOL[kind], Pathname.new(path.to_s)))
+              end
             end
+            # rubocop:enable Naming/MethodName
           end
-          # rubocop:enable Naming/MethodName
 
-          # Implements the OpenHAB TriggerHandler interface to process Watch Triggers
+          # Implements the openHAB TriggerHandler interface to process Watch Triggers
           class WatchTriggerHandler
-            include OpenHAB::Log
             include org.openhab.core.automation.handler.TriggerHandler
 
+            class << self
+              #
+              # Returns the directory to watch, subdir flag, and glob pattern to use
+              #
+              # @param [String] path The path provided to the watch trigger which may include glob patterns
+              # @param [String] glob The glob pattern provided by the user
+              #
+              # @return [Array<String,Boolean,String>,nil] An array of directory to watch,
+              #   whether to watch in subdirectories, and the glob pattern to use.
+              #   Returns nil if the given path doesn't exist all the way to root, e.g. /nonexistent
+              #
+              def dir_subdir_glob(path, glob)
+                pathname = Pathname.new(path)
+                return [pathname.dirname.to_s, false, path] if pathname.file?
+
+                dir = find_parent(pathname)
+                return unless dir
+
+                # we were given the exact existing directory to watch
+                if dir == pathname
+                  glob_pathname = Pathname.new(glob)
+                  subdirs = recursive_glob?(glob)
+                  unless glob_pathname.absolute? || glob.start_with?("**")
+                    glob = subdirs ? "**/#{glob}" : "#{path}/#{glob}"
+                  end
+                  return [path, subdirs, glob]
+                end
+
+                if glob != "*" # if it isn't the default glob
+                  logger.warn("The provided glob '#{glob}' is ignored because " \
+                              "the given path (#{path}) isn't an existing directory, " \
+                              "so it is used as the glob pattern")
+                end
+
+                relative_glob = pathname.relative_path_from(dir).to_s
+                subdir_flag = dir != pathname.dirname || recursive_glob?(relative_glob)
+                [dir.to_s, subdir_flag, path]
+              end
+
+              # Returns true if string contains glob characters
+              def glob?(string)
+                unless @regexp
+                  # (?<!X) is a negative lookbehind pattern: only match the pattern if it wasn't
+                  # preceded with X. In this case we want to match only non escaped glob chars
+                  glob_pattern = %w[** * ? [ ] { }].map { |char| Regexp.escape(char) }
+                                                   .join("|")
+                                                   .then { |pattern| "(?<!\\\\)(#{pattern})" }
+
+                  @regexp = Regexp.new(glob_pattern)
+                end
+                @regexp.match?(string)
+              end
+
+              # Returns true if string contains a recursive glob pattern (** or x/y)
+              def recursive_glob?(string)
+                /(?<!\\\\)\*\*/.match?(string) || Pathname.new(string).each_filename.to_a.size > 1
+              end
+
+              #
+              # Find the part of the path that exists on disk.
+              #
+              # /a/b/c/*/d/*.e -> /a/b/c if it exists
+              # /a/b/c/d/e/f -> /a/b/c if /a/b/c directory exists, but /a/b/c/d doesn't exist
+              # /a/b/c -> nil if /a doesn't exist
+              # / -> /
+              #
+              # @param [Pathname] pathname The pathname to check
+              # @return [Pathname,nil] The leading part of the path name that corresponds to
+              #   an existing directory. nil if none was found up until the root directory
+              #
+              def find_parent(pathname)
+                return pathname if pathname.root?
+
+                pathname.ascend { |part| return part if part.directory? && !part.root? }
+              end
+            end
+
             # Creates a new WatchTriggerHandler
-            # @param [Trigger] trigger OpenHAB trigger associated with handler
+            # @param [org.openhab.core.automation.Trigger] trigger
             #
             def initialize(trigger)
               @trigger = trigger
               config = trigger.configuration.properties.to_hash.transform_keys(&:to_sym)
-              @path = config[:path]
-              @watcher = Watcher.new(@path, config[:types], &watch_event_handler(config[:glob]))
+              @path, subdirs, glob = self.class.dir_subdir_glob(config[:path], config[:glob])
+              logger.trace { "WatchTriggerHandler#initialize path: #{@path}, subdirs: #{subdirs}, glob: #{glob}" }
+              unless @path
+                logger.warn("Watch error: the given path doesn't exist: '#{@path}'")
+                return
+              end
+              @watcher = Watcher.new(@path, subdirs, config[:types], &watch_event_handler(glob))
               @watcher.activate
-              logger.trace("Created watcher for #{@path}")
+              logger.trace { "Created watcher for #{@path} subdirs: #{subdirs}" }
             end
 
             # Create a lambda to use to invoke rule engine when file watch notification happens
             # @param [String] glob to match for notification events
             #
-            # @return [Lambda] lambda to execute on notification events
+            # @return [Proc] lambda to execute on notification events
             #
             def watch_event_handler(glob)
-              lambda { |watch_event|
-                logger.trace("Received event(#{watch_event})")
-                if watch_event.path.fnmatch?(glob)
-                  @rule_engine_callback&.triggered(@trigger, { 'event' => watch_event })
+              default_fs = java.nio.file.FileSystems.default
+              path_matcher = default_fs.get_path_matcher("glob:#{glob}")
+              lambda do |watch_event|
+                if path_matcher.matches(default_fs.get_path(watch_event.path.to_s))
+                  logger.trace do
+                    "Received event(#{watch_event}) glob: #{glob}, rule_engine_callback = #{@rule_engine_callback}"
+                  end
+                  @rule_engine_callback&.triggered(@trigger, { "event" => watch_event })
                 else
-                  logger.trace("Event #{watch_event} did not match glob(#{glob})")
+                  logger.trace { "Event #{watch_event} did not match glob(#{glob})" }
                 end
-              }
+              end
             end
 
-            # Called by OpenHAB to set the rule engine to invoke when triggered
-            # Must match java method name style
+            # Called by openHAB to set the rule engine to invoke when triggered
             def setCallback(callback) # rubocop:disable Naming/MethodName
               @rule_engine_callback = callback
             end
@@ -129,41 +281,44 @@ module OpenHAB
             # Dispose of handler which deactivates watcher
             #
             def dispose
-              logger.trace("Deactivating watcher for #{@path}")
-              @watcher&.deactivate
+              logger.trace { "Deactivating watcher for #{@path}" }
+              @watcher.deactivate
             end
           end
 
           # Implements the ScriptedTriggerHandlerFactory interface to create a new Trigger Handler
           class WatchTriggerHandlerFactory
+            include Singleton
             include org.openhab.core.automation.module.script.rulesupport.shared.factories.ScriptedTriggerHandlerFactory
 
-            # Invoked by the OpenHAB core to get a trigger handler for the supllied trigger
-            # @param [Trigger] trigger OpenHAB trigger
+            def initialize
+              Core.automation_manager.add_trigger_handler(
+                WATCH_TRIGGER_MODULE_ID,
+                self
+              )
+
+              Core.automation_manager.add_trigger_type(org.openhab.core.automation.type.TriggerType.new(
+                                                         WATCH_TRIGGER_MODULE_ID,
+                                                         nil,
+                                                         "A path change event is detected",
+                                                         "Triggers when a path change event is detected",
+                                                         nil,
+                                                         org.openhab.core.automation.Visibility::VISIBLE,
+                                                         nil
+                                                       ))
+              logger.trace("Added watch trigger handler")
+            end
+
+            # Invoked by openHAB core to get a trigger handler for the supllied trigger
+            # @param [org.openhab.core.automation.Trigger] trigger
             #
             # @return [WatchTriggerHandler] trigger handler for supplied trigger
             def get(trigger)
               WatchTriggerHandler.new(trigger)
             end
           end
-
-          #
-          # Creates trigger types and trigger type factories for OpenHAB
-          #
-          def self.add_watch_handler
-            java_import org.openhab.core.automation.type.TriggerType
-            OpenHAB::Core.automation_manager.add_trigger_handler(
-              WATCH_TRIGGER_MODULE_ID,
-              WatchTriggerHandlerFactory.new
-            )
-
-            OpenHAB::Core.automation_manager.add_trigger_type(watch_trigger_type)
-            OpenHAB::Log.logger(self).trace('Added watch trigger handler')
-          end
         end
       end
     end
   end
 end
-# Add the watch handler to OpenHAB
-OpenHAB::DSL::Rules::Triggers::WatchHandler.add_watch_handler

data/lib/openhab/dsl/rules/triggers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+      # Contains helper classes for implementing triggers.
+      # @!visibility private
+      module Triggers
+      end
+    end
+  end
+end

data/lib/openhab/dsl/rules.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module OpenHAB
+  module DSL
+    module Rules
+    end
+  end
+end