Ejemplo n.º 1
0
  @Override
  public void addReader(ChannelHandlerReadSubscription subscription) {
    super.addReader(subscription);

    if (!monitorCreated.getAndSet(true)) {
      // TODO remove this....
      for (int i = 0;
          i < 100 && channel.getConnectionState() == ConnectionState.NEVER_CONNECTED;
          i++) {
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
        }
      }
      // TODO optimize fields
      channel.createMonitor(this, CreateRequestFactory.createRequest("field()", this));
    }
  }
Ejemplo n.º 2
0
/** @author msekoranja */
public class PVAChannelHandler extends MultiplexedChannelHandler<PVAChannelHandler, PVStructure>
    implements ChannelRequester, GetFieldRequester, ChannelPutRequester, MonitorRequester {

  private final ChannelProvider pvaChannelProvider;
  private final short priority;
  private final PVATypeSupport pvaTypeSupport;

  private volatile Channel channel = null;

  private final AtomicBoolean monitorCreated = new AtomicBoolean(false);
  // private volatile Monitor monitor = null;

  private volatile Field channelType = null;
  private volatile boolean isChannelEnumType = false;

  private final AtomicBoolean channelPutCreated = new AtomicBoolean(false);
  private volatile ChannelPut channelPut = null;
  private volatile PVField channelPutValueField = null;

  private static final Logger logger = Logger.getLogger(PVAChannelHandler.class.getName());

  private static PVStructure standardPutPVRequest =
      CreateRequestFactory.createRequest("field(value)", null);
  private static PVStructure enumPutPVRequest =
      CreateRequestFactory.createRequest("field(value.index)", null);

  public PVAChannelHandler(
      String channelName,
      ChannelProvider channelProvider,
      short priority,
      PVATypeSupport typeSupport) {
    super(channelName);
    this.pvaChannelProvider = channelProvider;
    this.priority = priority;
    this.pvaTypeSupport = typeSupport;
  }

  /** @return the channel */
  public Channel getChannel() {
    return channel;
  }

  /** @return the channelType */
  public Field getChannelType() {
    return channelType;
  }

  @Override
  public String getRequesterName() {
    return this.getClass().getName();
  }

  @Override
  public void message(String message, MessageType messageType) {
    logger.log(toLoggerLevel(messageType), message);
  }

  /**
   * Converts MessageType to Java Logging API Level.
   *
   * @param messageType pvData message type.
   * @return Corresponded Java Logging API Level.
   */
  public static Level toLoggerLevel(MessageType messageType) {
    switch (messageType) {
      case info:
        return Level.INFO;
      case warning:
        return Level.WARNING;
      case error:
      case fatalError:
        return Level.SEVERE;
      default:
        return Level.INFO;
    }
  }

  private void reportStatus(String message, Status status) {
    if (!status.isSuccess()) {
      logger.log(Level.WARNING, message + ": " + status.getMessage());

      // for developers
      String dump = status.getStackDump();
      if (dump != null && !dump.isEmpty())
        logger.log(Level.FINER, message + ": " + status.getMessage() + ", cause:\n" + dump);
    }
  }

  @Override
  public void connect() {
    pvaChannelProvider.createChannel(getChannelName(), this, priority);
  }

  @Override
  public void channelCreated(Status status, Channel channel) {
    reportStatus("Failed to create channel instance '" + channel.getChannelName(), status);
    this.channel = channel;
  }

  @Override
  public void channelStateChange(Channel channel, ConnectionState connectionState) {
    try {

      // introspect
      if (connectionState == ConnectionState.CONNECTED) {
        channel.getField(this, null);
      } else {
        processConnection(this);
      }

    } catch (Exception ex) {
      reportExceptionToAllReadersAndWriters(ex);
    }
  }

  /* (non-Javadoc)
   * @see org.epics.pvaccess.client.GetFieldRequester#getDone(org.epics.pvdata.pv.Status, org.epics.pvdata.pv.Field)
   */
  @Override
  public void getDone(Status status, Field field) {
    reportStatus("Failed to instrospect channel '" + channel.getChannelName() + "'", status);

    if (status.isSuccess()) {
      channelType = field;

      Field valueField = ((Structure) channelType).getField("value");
      if (valueField != null && valueField.getID().equals("enum_t")) {
        isChannelEnumType = true;
        // TODO could create a monitor just to get value.choices
      } else isChannelEnumType = false;
    }

    processConnection(this);
  }

  @Override
  public boolean isConnected(PVAChannelHandler channel) {
    final Channel c = channel.getChannel();
    return c != null && c.isConnected();
  }

  @Override
  protected boolean isWriteConnected(PVAChannelHandler channel) {
    // NOTE: access-rights not yet supported
    final Channel c = channel.getChannel();
    return c != null && c.isConnected();
  }

  @Override
  public synchronized Map<String, Object> getProperties() {
    Map<String, Object> properties = new HashMap<String, Object>();
    if (channel != null) {
      properties.put("Channel name", channel.getChannelName());
      properties.put("Connection state", channel.getConnectionState().name());
      properties.put("Provider name", channel.getProvider().getProviderName());
      if (channel.getConnectionState() == Channel.ConnectionState.CONNECTED) {
        properties.put("Remote address", channel.getRemoteAddress());
        properties.put("Channel type", channelType.getID());
        // properties.put("Read access", channel.getReadAccess());
        // properties.put("Write access", channel.getWriteAccess());
      }
    }
    return properties;
  }

  @Override
  public void disconnect() {
    // Close the channel
    try {
      channel.destroy();
    } finally {
      channel = null;

      // monitor = null;
      monitorCreated.set(false);

      channelType = null;

      channelPut = null;
      channelPutValueField = null;
      channelPutCreated.set(false);
    }
  }

  static class WriteRequest {
    private final Object newValue;
    private final ChannelWriteCallback callback;

    public WriteRequest(Object newValue, ChannelWriteCallback callback) {
      this.newValue = newValue;
      this.callback = callback;
    }

    public Object getNewValue() {
      return newValue;
    }

    public ChannelWriteCallback getCallback() {
      return callback;
    }
  }

  private final LinkedList<WriteRequest> writeRequests = new LinkedList<WriteRequest>();

  @Override
  public void write(Object newValue, ChannelWriteCallback callback) {

    boolean wasEmpty;
    synchronized (writeRequests) {
      wasEmpty = writeRequests.isEmpty();
      writeRequests.add(new WriteRequest(newValue, callback));
    }

    if (!channelPutCreated.getAndSet(true)) {
      channel.createChannelPut(this, isChannelEnumType ? enumPutPVRequest : standardPutPVRequest);
    } else if (wasEmpty) {
      doNextWrite();
    }
  }

  private void doNextWrite() {
    WriteRequest writeRequest;
    synchronized (writeRequests) {
      writeRequest = writeRequests.peek();
    }

    if (writeRequest != null) {
      try {
        if (channelPutValueField == null) throw new RuntimeException("No 'value' field");

        fromObject(channelPutValueField, writeRequest.getNewValue());
        channelPut.put(false);
      } catch (Exception ex) {
        writeRequests.poll();
        writeRequest.getCallback().channelWritten(ex);
      }
    }
  }

  /* (non-Javadoc)
   * @see org.epics.pvaccess.client.ChannelPutRequester#channelPutConnect(org.epics.pvdata.pv.Status, org.epics.pvaccess.client.ChannelPut, org.epics.pvdata.pv.PVStructure, org.epics.pvdata.misc.BitSet)
   */
  @Override
  public void channelPutConnect(
      Status status, ChannelPut channelPut, PVStructure pvStructure, BitSet bitSet) {
    reportStatus("Failed to create ChannelPut instance", status);

    if (status.isSuccess()) {
      this.channelPut = channelPut;

      if (isChannelEnumType) {
        // handle inconsistent behavior
        this.channelPutValueField = pvStructure.getSubField("value");
        if (this.channelPutValueField instanceof PVStructure)
          this.channelPutValueField = ((PVStructure) pvStructure).getSubField("index");
      } else {
        this.channelPutValueField = pvStructure.getSubField("value");
      }

      // set BitSet
      bitSet.clear(); // re-connect case
      if (this.channelPutValueField != null) bitSet.set(channelPutValueField.getFieldOffset());
    }

    doNextWrite();
  }

  /* (non-Javadoc)
   * @see org.epics.pvaccess.client.ChannelPutRequester#putDone(org.epics.pvdata.pv.Status)
   */
  @Override
  public void putDone(Status status) {
    reportStatus("Failed to put value", status);

    WriteRequest writeRequest;
    synchronized (writeRequests) {
      writeRequest = writeRequests.poll();
    }

    if (writeRequest != null) {
      if (status.isSuccess()) {
        writeRequest.getCallback().channelWritten(null);
      } else {
        writeRequest.getCallback().channelWritten(new Exception(status.getMessage()));
      }

      doNextWrite();
    }
  }

  /* (non-Javadoc)
   * @see org.epics.pvaccess.client.ChannelPutRequester#getDone(org.epics.pvdata.pv.Status)
   */
  @Override
  public void getDone(Status status) {
    // never used, i.e. ChannelPut.get() never called
  }

  private static final Convert convert = ConvertFactory.getConvert();

  // TODO check if non-V types can ever be given as newValue
  private final void fromObject(PVField field, Object newValue) {
    // enum support
    if (isChannelEnumType) {
      // value.index int field expected
      PVInt indexPutField = (PVInt) channelPutValueField;

      int index = -1;
      if (newValue instanceof Number) {
        index = ((Number) newValue).intValue();
      } else if (newValue instanceof String) {
        String nv = (String) newValue;

        PVStructure lastValue = getLastMessagePayload();
        if (lastValue == null)
          throw new IllegalArgumentException(
              "no monitor on '" + getChannelName() + "' created to get list of valid enum choices");

        PVStringArray pvChoices = (PVStringArray) lastValue.getSubField("value.choices");
        StringArrayData data = new StringArrayData();
        pvChoices.get(0, pvChoices.getLength(), data);
        final String[] choices = data.data;

        for (int i = 0; i < choices.length; i++) {
          if (nv.equals(choices[i])) {
            index = i;
            break;
          }
        }

        if (index == -1)
          throw new IllegalArgumentException("enumeration '" + nv + "' is not a valid choice");
      }

      indexPutField.put(index);

      return;
    }

    if (channelPutValueField instanceof PVScalar) {
      if (newValue instanceof Double)
        convert.fromDouble((PVScalar) field, ((Double) newValue).doubleValue());
      else if (newValue instanceof Integer)
        convert.fromInt((PVScalar) field, ((Integer) newValue).intValue());
      else if (newValue instanceof String) convert.fromString((PVScalar) field, (String) newValue);
      else if (newValue instanceof Byte)
        convert.fromByte((PVScalar) field, ((Byte) newValue).byteValue());
      else if (newValue instanceof Short)
        convert.fromShort((PVScalar) field, ((Short) newValue).shortValue());
      else if (newValue instanceof Long)
        convert.fromLong((PVScalar) field, ((Long) newValue).longValue());
      else if (newValue instanceof Float)
        convert.fromFloat((PVScalar) field, ((Float) newValue).floatValue());
      else
        throw new RuntimeException(
            "Unsupported write, cannot put '"
                + newValue.getClass()
                + "' into scalar '"
                + channelPutValueField.getField()
                + "'");
    } else if (channelPutValueField instanceof PVScalarArray) {
      // if it's a ListNumber, extract the array
      if (newValue instanceof ListNumber) {
        ListNumber data = (ListNumber) newValue;
        Object wrappedArray = CollectionNumbers.wrappedArray(data);
        if (wrappedArray == null) {
          newValue = CollectionNumbers.doubleArrayCopyOf(data);
        } else {
          newValue = wrappedArray;
        }
      } else if (!newValue.getClass().isArray()) {
        // create an array
        Object newValueArray = Array.newInstance(newValue.getClass(), 1);
        Array.set(newValueArray, 0, newValue);
        newValue = newValueArray;
      }

      if (newValue instanceof double[])
        convert.fromDoubleArray(
            (PVScalarArray) field, 0, ((double[]) newValue).length, (double[]) newValue, 0);
      else if (newValue instanceof int[])
        convert.fromIntArray(
            (PVScalarArray) field, 0, ((int[]) newValue).length, (int[]) newValue, 0);
      else if (newValue instanceof String[])
        convert.fromStringArray(
            (PVScalarArray) field, 0, ((String[]) newValue).length, (String[]) newValue, 0);
      // special case from string to array
      else if (newValue instanceof String) {
        String str = ((String) newValue).trim();

        // remove []
        if (str.charAt(0) == '[' && str.charAt(str.length() - 1) == ']')
          str = str.substring(1, str.length() - 1);

        // split on commas and whitespaces
        String[] splitValues = str.split("[,\\s]+");
        convert.fromStringArray((PVScalarArray) field, 0, splitValues.length, splitValues, 0);
      } else if (newValue instanceof byte[])
        convert.fromByteArray(
            (PVScalarArray) field, 0, ((byte[]) newValue).length, (byte[]) newValue, 0);
      else if (newValue instanceof short[])
        convert.fromShortArray(
            (PVScalarArray) field, 0, ((short[]) newValue).length, (short[]) newValue, 0);
      else if (newValue instanceof long[])
        convert.fromLongArray(
            (PVScalarArray) field, 0, ((long[]) newValue).length, (long[]) newValue, 0);
      else if (newValue instanceof float[])
        convert.fromFloatArray(
            (PVScalarArray) field, 0, ((float[]) newValue).length, (float[]) newValue, 0);
      else
        throw new RuntimeException(
            "Unsupported write, cannot put '"
                + newValue.getClass()
                + "' into array'"
                + channelPutValueField.getField()
                + "'");
    } else
      throw new RuntimeException(
          "Unsupported write, cannot put '"
              + newValue.getClass()
              + "' into '"
              + channelPutValueField.getField()
              + "'");
  }

  @Override
  protected PVATypeAdapter findTypeAdapter(ValueCache<?> cache, PVAChannelHandler connection) {
    PVATypeAdapter pta = null;
    try {
      pta = pvaTypeSupport.find(cache, connection);
    } catch (Throwable th) {
      th.printStackTrace();
    }
    return pta;
  }

  @Override
  public void addReader(ChannelHandlerReadSubscription subscription) {
    super.addReader(subscription);

    if (!monitorCreated.getAndSet(true)) {
      // TODO remove this....
      for (int i = 0;
          i < 100 && channel.getConnectionState() == ConnectionState.NEVER_CONNECTED;
          i++) {
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
        }
      }
      // TODO optimize fields
      channel.createMonitor(this, CreateRequestFactory.createRequest("field()", this));
    }
  }

  /* (non-Javadoc)
   * @see org.epics.pvdata.monitor.MonitorRequester#monitorConnect(org.epics.pvdata.pv.Status, org.epics.pvdata.monitor.Monitor, org.epics.pvdata.pv.Structure)
   */
  @Override
  public void monitorConnect(Status status, Monitor monitor, Structure structure) {
    reportStatus("Failed to create monitor", status);

    if (status.isSuccess()) {
      // this.monitor = monitor;
      monitor.start();
    }
  }

  /* (non-Javadoc)
   * @see org.epics.pvdata.monitor.MonitorRequester#monitorEvent(org.epics.pvdata.monitor.Monitor)
   */
  @Override
  public void monitorEvent(Monitor monitor) {
    MonitorElement monitorElement;
    while ((monitorElement = monitor.poll()) != null) {
      // TODO combine bitSet, etc.... do we need to copy structure?
      processMessage(monitorElement.getPVStructure());
      monitor.release(monitorElement);
    }
  }

  /* (non-Javadoc)
   * @see org.epics.pvdata.monitor.MonitorRequester#unlisten(org.epics.pvdata.monitor.Monitor)
   */
  @Override
  public void unlisten(Monitor monitor) {
    // TODO Auto-generated method stub
  }

  @Override
  public String toString() {
    return "PVAChannelHandler [getChannelName()=" + getChannelName() + "]";
  }
}