Module: OpenHAB::DSL::Imports

Defined in:

lib/rspec/openhab/dsl/imports.rb

Defined Under Namespace

Classes: Bundle, BundleContext, CallbacksMap, ComponentContext, EventAdmin, EventHandler, EventManager, ScriptExtensionManagerWrapper, SynchronousExecutor, SynchronousExecutorMap, VolatileStorage, VolatileStorageService

Class Attribute Summary

• .api ⇒ Object

  Returns the value of attribute api.

Class Method Summary

• .import_presets ⇒ Object

Class Attribute Details

.api ⇒ Object

Returns the value of attribute api.

# File 'lib/rspec/openhab/dsl/imports.rb', line 255

def api
  @api
end

Class Method Details

.import_presets ⇒ Object

# File 'lib/rspec/openhab/dsl/imports.rb', line 257

def import_presets
  return if @imported

  @imported = true

  org.openhab.core.common.ThreadPoolManager.field_accessor :pools
  org.openhab.core.common.ThreadPoolManager.pools = SynchronousExecutorMap.new

  # OSGiEventManager will create a ThreadedEventHandler on OSGi activation;
  # we're skipping that, and directly sending to a non-threaded event handler.
  em = EventManager.new
  eh = EventHandler.new(em.typedEventSubscribers, em.typedEventFactories)
  ea = EventAdmin.new(eh)
  ep = org.openhab.core.internal.events.OSGiEventPublisher.new(ea)
  bc = BundleContext.new(em)
  cc = ComponentContext.new(bc)
  cc.properties["measurementSystem"] = api.measurement_system if api

  # the registries!
  ss = VolatileStorageService.new
  mr = org.openhab.core.internal.items.MetadataRegistryImpl.new
  OpenHAB::Core::OSGI.register_service("org.openhab.core.items.MetadataRegistry", mr)
  mr.managed_provider = mmp = org.openhab.core.internal.items.ManagedMetadataProviderImpl.new(ss)
  mr.add_provider(mmp)
  gmp = org.openhab.core.model.item.internal.GenericMetadataProvider.new
  mr.add_provider(gmp)
  ir = org.openhab.core.internal.items.ItemRegistryImpl.new(mr)
  ir.managed_provider = mip = org.openhab.core.items.ManagedItemProvider.new(ss, nil)
  ir.add_provider(mip)
  ir.event_publisher = ep
  up = org.openhab.core.internal.i18n.I18nProviderImpl.new(cc)
  ir.unit_provider = up
  ir.item_state_converter = org.openhab.core.internal.items.ItemStateConverterImpl.new(up)
  tr = org.openhab.core.thing.internal.ThingRegistryImpl.new
  mtr = org.openhab.core.automation.internal.type.ModuleTypeRegistryImpl.new
  rr = org.openhab.core.automation.internal.RuleRegistryImpl.new
  rr.module_type_registry = mtr
  rr.managed_provider = mrp = org.openhab.core.automation.ManagedRuleProvider.new(ss)
  rr.add_provider(mrp)
  iclr = org.openhab.core.thing.link.ItemChannelLinkRegistry.new(tr, ir)
  ctr = org.openhab.core.thing.type.ChannelTypeRegistry.new
  ttr = org.openhab.core.thing.type.ThingTypeRegistry.new(ctr)

  safe_emf = org.openhab.core.model.core.internal.SafeEMFImpl.new
  model_repository = org.openhab.core.model.core.internal.ModelRepositoryImpl.new(safe_emf)

  # set up state descriptions
  sds = org.openhab.core.internal.service.StateDescriptionServiceImpl.new
  gip = org.openhab.core.model.item.internal.GenericItemProvider.new(model_repository, gmp, {})
  sds.add_state_description_fragment_provider(gip)
  msdfp = org.openhab.core.internal.items.MetadataStateDescriptionFragmentProvider.new(mr, {})
  sds.add_state_description_fragment_provider(msdfp)
  csdp = org.openhab.core.thing.internal.ChannelStateDescriptionProvider.new(iclr, ttr, tr)
  csdp.activate(org.osgi.framework.Constants::SERVICE_RANKING => java.lang.Integer.new(-1))
  sds.add_state_description_fragment_provider(csdp)
  ir.state_description_service = sds

  # set up stuff accessed from rules
  preset = org.openhab.core.automation.module.script.internal.defaultscope
              .DefaultScriptScopeProvider.new(ir, tr, rr, ep)
  preset.default_presets.each do |preset_name|
    preset.import_preset(nil, preset_name).each do |(name, value)|
      next if name == "File"

      if value.respond_to?(:ruby_class)
        Object.const_set(name, value.ruby_class)
      elsif /[[:upper:]]/.match?(name[0])
        Object.const_set(name, value)
      else
        eval("$#{name} = value", binding, __FILE__, __LINE__) # $ir = value # rubocop:disable Security/Eval
      end
    end
  end

  # set up the rules engine part 1
  mtrbp = org.openhab.core.automation.internal.provider.ModuleTypeResourceBundleProvider.new(nil)
  mtgp = org.openhab.core.automation.internal.parser.gson.ModuleTypeGSONParser.new
  mtrbp.add_parser(mtgp, {})
  bundle = Bundle.new("org.openhab.core.bundles",
                      "org.openhab.core.automation.module.script.rulesupport",
                      OpenHAB::Core.openhab_version)
  mtrbp.process_automation_provider(bundle)
  bundle = Bundle.new("org.openhab.core.bundles",
                      "org.openhab.core.automation",
                      OpenHAB::Core.openhab_version)
  mtrbp.process_automation_provider(bundle)
  mtr.add_provider(mtrbp)

  # set up script support stuff
  srp = org.openhab.core.automation.module.script.rulesupport.shared.ScriptedRuleProvider.new
  rr.add_provider(srp)
  scmhf = org.openhab.core.automation.module.script.rulesupport.internal.ScriptedCustomModuleHandlerFactory.new
  scmtp = org.openhab.core.automation.module.script.rulesupport.internal.ScriptedCustomModuleTypeProvider.new
  mtr.add_provider(scmtp)
  spmhf = org.openhab.core.automation.module.script.rulesupport.internal.ScriptedPrivateModuleHandlerFactory.new
  se = org.openhab.core.automation.module.script.rulesupport.internal
          .RuleSupportScriptExtension.new(rr, srp, scmhf, scmtp, spmhf)
  sew = ScriptExtensionManagerWrapper.new(se)
  $se = $scriptExtension = sew

  # need to create some singletons referencing registries
  org.openhab.core.model.script.ScriptServiceUtil.new(ir, tr, ep, nil, nil)
  org.openhab.core.model.script.internal.engine.action.SemanticsActionService.new(ir)

  # link up event bus infrastructure
  iu = org.openhab.core.internal.items.ItemUpdater.new(ir)
  ief = org.openhab.core.items.events.ItemEventFactory.new

  sc = org.openhab.core.internal.common.SafeCallerImpl.new({})
  aum = org.openhab.core.thing.internal.AutoUpdateManager.new({ "enabled" => "true" }, nil, ep, iclr, mr, tr)
  cm = org.openhab.core.thing.internal.CommunicationManager.new(aum, nil, nil, iclr, ir, nil, ep, sc, tr)

  em.add_event_subscriber(iu)
  em.add_event_subscriber(cm)
  em.add_event_factory(ief)

  # set up the rules engine part 2
  k = org.openhab.core.automation.internal.module.factory.CoreModuleHandlerFactory
  # depending on OH version, this class is set up differently
  cmhf = begin
    cmhf = k.new
    cmhf.item_registry = ir
    cmhf.event_publisher = ep
    cmhf.activate(bc)
    cmhf
  rescue ArgumentError
    k.new(bc, ep, ir)
  end

  rs = org.openhab.core.internal.service.ReadyServiceImpl.new
  re = org.openhab.core.automation.internal.RuleEngineImpl.new(mtr, rr, ss, rs)
  # overwrite thCallbacks to one that will spy to remove threading
  field = re.class.java_class.declared_field("thCallbacks")
  field.accessible = true
  field.set(re, CallbacksMap.new)
  re.class.field_accessor :executor
  re.executor = SynchronousExecutor.instance
  re.add_module_handler_factory(cmhf)
  re.add_module_handler_factory(scmhf)
  re.add_module_handler_factory(spmhf)
  re.on_ready_marker_added(nil)

  # enable event logging
  el = org.openhab.core.io.monitor.internal.EventLogger.new(rs)
  em.add_event_subscriber(el)
  el.on_ready_marker_added(nil)
end