openhab-scripting 2.9.1

data/README.md

@@ -0,0 +1,23 @@
+# JRuby OpenHAB Scripting Library
+
+
+<p align="center">
+    <img alt="GitHub release (latest SemVer including pre-releases)" src="https://img.shields.io/github/v/release/boc-tothefuture/openhab-jruby?include_prereleases"/>
+    <img alt="GitHub Workflow Status" src="https://img.shields.io/github/workflow/status/boc-tothefuture/openhab-jruby/Openhab-JRuby-Scripting"/>
+    <img alt="GitHub contributors" src="https://img.shields.io/github/contributors/boc-tothefuture/openhab-jruby"/>
+    <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/boc-tothefuture/openhab-jruby">
+    <img alt="SemVer version observance" src="https://img.shields.io/badge/semver-2.0.0-blue"/>
+    <a href="https://conventionalcommits.org"/>
+       <img alt="Convention commits observance" src="https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg"/>
+	</a>
+  </p>
+
+
+## Usage
+Usage documentation is located [here](https://boc-tothefuture.github.io/openhab-jruby/).
+
+## Discussion
+Please see [this thread](https://community.openhab.org/t/jruby-openhab-rules-system/110598) on the OpenHAB forum for further discussion.  Ideas and suggestions are welcome.
+
+## Library Status
+This is an alpha and syntax and all elements are subject to change as the library evolves.

data/Rakefile

@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+
+require 'rake/packagetask'
+require 'rubocop/rake_task'
+require 'bundler/gem_tasks'
+require 'yard'
+require 'English'
+require 'time'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'open-uri'
+require 'tty-command'
+require 'process_exists'
+require 'cuke_linter'
+require 'erb'
+
+require_relative 'lib/openhab/version'
+
+PACKAGE_DIR = 'pkg'
+TMP_DIR = 'tmp'
+OPENHAB_DIR = File.join(TMP_DIR, 'openhab')
+DOCS_DIR = 'doc'
+OPENHAB_VERSION = '3.0.0'
+JRUBY_BUNDLE = File.realpath(Dir.glob('bundle/*.jar').first)
+KARAF_CLIENT_PATH = File.join(OPENHAB_DIR, 'runtime/bin/client')
+KARAF_CLIENT_ARGS = [KARAF_CLIENT_PATH, '-p', 'habopen'].freeze
+KARAF_CLIENT = KARAF_CLIENT_ARGS.join(' ')
+
+DEPLOY_DIR = File.join(OPENHAB_DIR, 'conf/automation/jsr223/ruby/personal')
+LIB_DIR = File.join(OPENHAB_DIR, 'conf/automation/lib/ruby/lib/')
+STATE_DIR = File.join(OPENHAB_DIR, 'rake_state')
+YARD_DIR = File.join('docs', 'yard')
+CUCUMBER_LOGS = File.join(TMP_DIR, 'cucumber_logs')
+SERVICES_CONFIG = File.join(OPENHAB_DIR, 'conf/services/jruby.cfg')
+
+CLEAN << PACKAGE_DIR
+CLEAN << DEPLOY_DIR
+CLEAN << CUCUMBER_LOGS
+CLEAN << YARD_DIR
+CLEAN << '.yardoc'
+
+CLOBBER << OPENHAB_DIR
+
+desc 'Generate Yard docs'
+task :yard do
+  YARD::Rake::YardocTask.new do |t|
+    t.files = ['lib/**/*.rb'] # optional
+    t.stats_options = ['--list-undoc'] # optional
+  end
+end
+
+RuboCop::RakeTask.new do |task|
+  task.patterns = ['lib/**/*.rb', 'test/**/*.rb']
+  task.fail_on_error = false
+end
+
+desc 'Lint Code'
+task :lint do
+  Rake::Task['rubocop'].invoke
+  CukeLinter.lint
+end
+
+desc 'Start Documentation Server'
+task docs: :yard do
+  sh 'bundle exec jekyll clean'
+  sh 'bundle exec jekyll server --config docs/_config.yml'
+end
+
+task :yard_server do
+  sh 'bundle exec guard'
+end
+
+desc 'Run Cucumber Features'
+task :features, [:feature] => ['openhab:warmup', 'openhab:deploy', CUCUMBER_LOGS] do |_, args|
+  # Rake::Task['openhab:warmup'].execute
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "--tags 'not @wip and not @not_implemented' --format pretty #{args[:feature]}"
+  end
+end
+
+desc 'Get OpenHAB-JRuby Version'
+task :version do
+  puts OpenHAB::VERSION
+end
+
+namespace :gh do
+  zip_path = ''
+
+  directory PACKAGE_DIR
+
+  desc 'Package for release'
+  task package: [PACKAGE_DIR] do
+    zip_filename = "OpenHABJRuby-#{OpenHAB::VERSION}.zip"
+    zip_path = File.join(PACKAGE_DIR, zip_filename)
+    target_dir = 'lib/'
+    sh 'zip', '-r', zip_path, target_dir
+  end
+
+  desc 'Package for release'
+  task release: :package do
+    sh 'gh', 'release', 'create', OpenHAB::VERSION, '-p', '-F', 'CHANGELOG.md', zip_path, JRUBY_BUNDLE
+  end
+end
+
+namespace :openhab do
+  def command_success?(command)
+    cmd = TTY::Command.new(printer: :null)
+    cmd.run!(command).success?
+  end
+
+  def running?(fail_on_error: false)
+    karaf_status = File.join(OPENHAB_DIR, 'runtime/bin/status')
+
+    return false unless File.exist? karaf_status
+
+    if fail_on_error
+      fail_on_error(karaf_status)
+      true
+    else
+      command_success? karaf_status
+    end
+  end
+
+  # There can be a delay between when OpenHAB is running and ready to process commands
+  def ready?(fail_on_error: false)
+    return unless running?
+
+    if fail_on_error
+      fail_on_error("#{KARAF_CLIENT} 'system:version'")
+      true
+    else
+      cmd = TTY::Command.new(printer: :null)
+      cmd.run!("#{KARAF_CLIENT} 'system:version'").success?
+    end
+  end
+
+  def ensure_openhab_running
+    abort('Openhab not running') unless running?
+  end
+
+  def print_and_flush(string)
+    print string
+    $stdout.flush
+  end
+
+  def fail_on_error(command, env = {})
+    cmd = TTY::Command.new
+    out, = cmd.run(command, env: env, only_output_on_error: true)
+    out
+  end
+
+  def karaf(command)
+    fail_on_error("#{KARAF_CLIENT} '#{command}'")
+  end
+
+  def wait_for(duration, task)
+    print_and_flush "Waiting for up to #{duration} seconds for #{task}"
+    duration.times do
+      if yield
+        puts ''
+        return true
+      end
+
+      print_and_flush '.'
+      sleep 1
+    end
+    puts ''
+    false
+  end
+
+  def gem_home
+    full_path = File.realpath OPENHAB_DIR
+    File.join(full_path, '/conf/automation/lib/ruby/gem_home')
+  end
+
+  def ruby_env
+    #   { 'RUBYLIB' => File.join(full_path, '/conf/automation/lib/ruby/lib'),
+    { 'GEM_HOME' => gem_home }
+  end
+
+  def state(task)
+    Rake::Task[STATE_DIR.to_s].execute
+    task_file = File.join(STATE_DIR, task)
+    if File.exist? task_file
+      puts "Skipping task(#{task}), task already up to date"
+    else
+      yield
+      touch task_file
+    end
+  end
+
+  directory OPENHAB_DIR
+  directory DEPLOY_DIR
+  directory LIB_DIR
+  directory STATE_DIR
+  directory CUCUMBER_LOGS
+
+  desc 'Download Openhab and unzip it'
+  task download: [OPENHAB_DIR] do |task|
+    state(task.name) do
+      openhab_zip = "openhab-#{OPENHAB_VERSION}.zip"
+      Dir.chdir(OPENHAB_DIR) do
+        puts "Downloading #{openhab_zip}"
+        IO.copy_stream(
+          open("https://openhab.jfrog.io/openhab/libs-release/org/openhab/distro/openhab/#{OPENHAB_VERSION}/openhab-#{OPENHAB_VERSION}.zip"), openhab_zip
+        )
+        fail_on_error("unzip #{openhab_zip}")
+        rm openhab_zip
+      end
+    end
+  end
+
+  desc 'Add RubyLib and GEM_HOME to start.sh'
+  task rubylib: :download do |task|
+    #    state(task.name) do
+    #      paths = ruby_env
+    #      Dir.chdir(OPENHAB_DIR) do
+    #        start_file = 'start.sh'
+    #
+    #        settings = {
+    #          /^export RUBYLIB=/ => "export RUBYLIB=#{paths['RUBYLIB']}\n",
+    #          /^export GEM_HOME=/ => "export GEM_HOME=#{paths['GEM_HOME']}\n"
+    #        }
+    #
+    #        settings.each do |regex, line|
+    #          lines = File.readlines(start_file)
+    #          unless lines.grep(regex).any?
+    #            lines.insert(-2, line)
+    #            File.write(start_file, lines.join)
+    #          end
+    #        end
+    #      end
+    #    end
+  end
+
+  desc 'Setup services config'
+  task services: :download do |task|
+    state(task.name) do
+      services_config = ERB.new <<~EOF
+        org.openhab.automation.jrubyscripting:gem_home=<%= gem_home %>
+      EOF
+      File.write(SERVICES_CONFIG, services_config.result)
+    end
+  end
+
+  def bundle_id
+    karaf('bundle:list --no-format org.openhab.automation.jrubyscripting').lines.last[/^\d\d\d/].chomp
+  end
+
+  desc 'Install JRuby Bundle'
+  task install: [:download, :rubylib, :services, DEPLOY_DIR] do |task|
+    state(task.name) do
+      start
+      if karaf('bundle:list --no-format org.openhab.automation.jrubyscripting').include?('Active')
+        puts 'Bundle Active, no action taken'
+      else
+        unless karaf('bundle:list --no-format org.openhab.automation.jrubyscripting').include?('Installed')
+          karaf("bundle:install file://#{JRUBY_BUNDLE}")
+        end
+        karaf("bundle:start #{bundle_id}")
+      end
+    end
+  end
+
+  desc 'Upgrade JRuby Bundle'
+  task :upgrade, [:file] do |_, args|
+    start
+    if karaf('bundle:list --no-format org.openhab.automation.jrubyscripting').include?('Active')
+      karaf("bundle:update #{bundle_id} file://#{args[:file]}")
+    else
+      abort "Bundle not installed, can't upgrade"
+    end
+  end
+
+  desc 'Configure'
+  task configure: %i[download] do |task|
+    # Set log levels
+    state(task.name) do
+      start
+      karaf('log:set TRACE jsr223')
+      karaf('log:set TRACE org.openhab.core.automation')
+      karaf('log:set TRACE org.openhab.binding.jrubyscripting')
+      karaf('openhab:users add foo foo administrator')
+      sh 'rsync', '-aih', 'config/userdata/', File.join(OPENHAB_DIR, 'userdata')
+    end
+  end
+
+  def start
+    if running?
+      puts 'OpenHAB already running'
+      return
+    end
+
+    env = ruby_env
+    env = env.merge({ 'KARAF_REDIRECT' => File.join(File.realpath(TMP_DIR), 'karaf.log'),
+                      'EXTRA_JAVA_OPTS' => '-Xmx4g' })
+
+    Dir.chdir(OPENHAB_DIR) do
+      puts 'Starting OpenHAB'
+      pid = spawn(env, 'runtime/bin/start')
+      Process.detach(pid)
+    end
+
+    wait_for(20, 'OpenHAB to start') { running? }
+    abort 'Unable to start OpenHAB' unless running?(fail_on_error: true)
+
+    wait_for(20, 'OpenHAB to become ready') { ready? }
+    abort 'OpenHAB did not become ready' unless ready?(fail_on_error: true)
+
+    puts 'OpenHAB started and ready'
+  end
+
+  desc 'Start OpenHAB'
+  task start: %i[download] do
+    start
+  end
+
+  def stop
+    if running?
+      pid = File.read(File.join(OPENHAB_DIR, 'userdata/tmp/karaf.pid')).chomp.to_i
+      Dir.chdir(OPENHAB_DIR) do
+        fail_on_error('runtime/bin/stop')
+      end
+      stopped = wait_for(20, 'OpenHAB to stop') { Process.exists?(pid) == false }
+      abort 'Unable to stop OpenHAB' unless stopped
+    end
+
+    puts 'OpenHAB Stopped'
+  end
+
+  desc 'Stop OpenHAB'
+  task :stop do
+    stop
+  end
+
+  def restart
+    puts 'Restarting OpenHAB'
+    stop
+    start
+    puts 'OpenHAB Restarted'
+  end
+
+  desc 'Clobber local Openhab'
+  task :clobber do
+    stop if running?
+
+    rm_rf OPENHAB_DIR
+  end
+
+  desc 'Create a Dev Dump in OpenHAB and wait until its complete'
+  task :dump do
+    dumps = File.join(OPENHAB_DIR, 'userdata', '*.zip')
+
+    puts 'Deleting any existing dumps'
+    dump = Dir[dumps].each { |dump_file| rm dump_file }
+
+    karaf('dev:dump-create')
+
+    wait_for(30, 'Dump to be created') do
+      Dir[dumps].any?
+    end
+    dump = Dir[dumps].first
+    puts "Found dev dump #{dump}"
+    dump_sizes = Array.new(10)
+    wait_for(120, 'Dump size to not increase for 10 seconds') do
+      dump_sizes << File.size(dump)
+      dump_sizes.last(10).uniq.length == 1
+    end
+  end
+
+  desc 'Warmup OpenHab environment'
+  task warmup: [:prepare, DEPLOY_DIR] do
+    start
+    openhab_log = File.join(OPENHAB_DIR, 'userdata/logs/openhab.log')
+
+    file = File.join('openhab_rules', 'warmup.rb')
+    dest_file = File.join(DEPLOY_DIR, "#{File.basename(file, '.rb')}_#{Time.now.to_i}.rb")
+    cp file, dest_file
+    wait_for(20, 'OpenHAB to warmup') do
+      File.foreach(openhab_log).grep(/OpenHAB warmup complete/).any?
+    end
+    rm dest_file
+  end
+
+  desc 'Prepare local Openhab'
+  task prepare: [:download, :rubylib, :install, :configure, :deploy, CUCUMBER_LOGS]
+
+  desc 'Setup local Openhab'
+  task setup: %i[prepare stop]
+
+  desc 'Deploy to local Openhab'
+  task deploy: %i[download build] do |_task|
+    gem_file = File.join(PACKAGE_DIR, "openhab-scripting-#{OpenHAB::VERSION}.gem")
+    fail_on_error("gem install #{gem_file}", ruby_env)
+  end
+
+  desc 'Deploy adhoc test Openhab'
+  task adhoc: :deploy do
+    mkdir_p DEPLOY_DIR
+    Dir.glob(File.join(DEPLOY_DIR, '*.rb')) { |file| rm file }
+    Dir.glob(File.join('test/', '*.rb')) do |file|
+      dest_name = "#{File.basename(file, '.rb')}_#{Time.now.to_i}.rb"
+      cp file, File.join(deploy_dir, dest_name)
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'openhab/scripting'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here