示例#1
0
  /** {@inheritDoc} */
  @Override
  protected void internalReceiveCommand(String itemName, Command command) {
    try {
      logger.debug("internalReceiveCommand: itemName '{}', command '{}'", itemName, command);

      // Lookup the MiOS Unit name and property for this item
      String unitName = getMiosUnitName(itemName);

      MiosUnitConnector connector = getMiosConnector(unitName);
      if (connector == null) {
        logger.warn(
            "Received command ({}) for item '{}' but no connector found for MiOS Unit '{}', ignoring",
            new Object[] {command.toString(), itemName, unitName});
        return;
      }

      if (!connector.isConnected()) {
        logger.warn(
            "Received command ({}) for item '{}' but the connection to the MiOS Unit '{}' is down, ignoring",
            new Object[] {command.toString(), itemName, unitName});
        return;
      }

      for (BindingProvider provider : providers) {
        if (provider instanceof MiosBindingProvider) {
          MiosBindingProviderImpl miosProvider = (MiosBindingProviderImpl) provider;
          MiosBindingConfig config = miosProvider.getMiosBindingConfig(itemName);

          if (config != null) {
            ItemRegistry reg = miosProvider.getItemRegistry();

            if (reg != null) {
              Item item = reg.getItem(config.getItemName());
              State state = item.getState();
              connector.invokeCommand(config, command, state);
            } else {
              logger.warn(
                  "internalReceiveCommand: Missing ItemRegistry for item '{}' command '{}'",
                  itemName,
                  command);
            }
          } else {
            logger.trace(
                "internalReceiveCommand: Missing BindingConfig for item '{}' command '{}'",
                itemName,
                command);
          }
        }
      }

    } catch (Exception e) {
      logger.error("Error handling command", e);
    }
  }
示例#2
0
  private void internalPropertyUpdate(String property, State value, boolean incremental)
      throws Exception {
    int bound = 0;

    if (value == null) {
      logger.trace("internalPropertyUpdate: Value is null for Property '{}', ignored.", property);
      return;
    }

    for (BindingProvider provider : providers) {
      if (provider instanceof MiosBindingProvider) {
        MiosBindingProviderImpl miosProvider = (MiosBindingProviderImpl) provider;

        for (String itemName : miosProvider.getItemNamesForProperty(property)) {

          MiosBindingConfig config = miosProvider.getMiosBindingConfig(itemName);

          if (config != null) {
            // Transform whatever value we have, based upon the
            // Transformation Service specified in the Binding
            // Config.

            State newValue = config.transformIn(value);

            if (newValue != value) {
              logger.trace(
                  "internalPropertyUpdate: transformation performed, from '{}' to '{}'",
                  value,
                  newValue);
            }

            //
            // Set the value only if:
            // * we're running Incrementally OR;
            // * the CURRENT value is UNDEFINED OR;
            // * the CURRENT value is different from the NEW value
            //
            // This is to handle a case where the MiOS Unit
            // "restarts" and floods us with a bunch of the same
            // data. In this case, we don't want to flood the Items,
            // since it may re-trigger a bunch of Rules in an
            // unnecessary manner.
            //
            if (incremental) {
              logger.debug(
                  "internalPropertyUpdate: BOUND (Incr) Updating '{} {mios=\"{}\"}' to '{}'",
                  itemName,
                  property,
                  newValue);

              eventPublisher.postUpdate(itemName, newValue);
            } else {
              ItemRegistry reg = miosProvider.getItemRegistry();
              State oldValue = reg.getItem(itemName).getState();

              if ((oldValue == null && newValue != null)
                  || (UnDefType.UNDEF.equals(oldValue) && !UnDefType.UNDEF.equals(newValue))
                  || !oldValue.equals(newValue)) {
                logger.debug(
                    "internalPropertyUpdate: BOUND (Full) Updating '{} {mios=\"{}\"}' to '{}', was '{}'",
                    new Object[] {itemName, property, newValue, oldValue});

                eventPublisher.postUpdate(itemName, newValue);
              } else {
                logger.trace(
                    "internalPropertyUpdate: BOUND (Full) Ignoring '{} {mios=\"{}\"}' to '{}', was '{}'",
                    new Object[] {itemName, property, newValue, oldValue});
              }
            }
            bound++;
          } else {
            logger.trace(
                "internalPropertyUpdate: Found null BindingConfig for item '{}' property '{}'",
                itemName,
                property);
          }
        }
      }
    }

    if (bound == 0) {
      logger.trace("internalPropertyUpdate: NOT BOUND {mios=\"{}\"}, value={}", property, value);
    } else {
      logger.trace(
          "internalPropertyUpdate: BOUND {mios=\"{}\"}, value={}, bound {} time(s)",
          new Object[] {property, value, bound});
    }
  }