Dummy method to check if this device is responding

@throws DevFailed
323969
@Override
    public void ping() throws DevFailed {
        MDC.setContextMap(contextMap);
        xlogger.entry();
        deviceMonitoring.startRequest("Operation ping");
        xlogger.exit();
    }
212400
public void init(final DeviceProxy deviceProxy, final String devname) throws DevFailed {
        // super.init(deviceProxy, devname);
        deviceProxy.setFull_class_name("DeviceProxy(" + name(deviceProxy) + ")");
    }
793803
public DeviceData command_inout_reply(int id, int timeout) throws DevFailed, AsynReplyNotArrived {
        return deviceProxyDAO.command_inout_reply(this, id, timeout);
    }
658024
protected void check_asynch_reply(Request request, int id, String idl_cmd) throws DevFailed, AsynReplyNotArrived {
        deviceProxyDAO.check_asynch_reply(this, request, id, idl_cmd);
    }
1043877
public DeviceData command_inout(String command, DeviceData argin) throws DevFailed {
		return iConnection.command_inout(this, command, argin);
	}
774103
public void poll_command(final DeviceProxy deviceProxy, final String cmdname, final int period)
		    throws DevFailed {
		poll_object(deviceProxy, cmdname, "command", period);
    }
481348
@Override
    protected  void checkDeviceConnection(DeviceProxy deviceProxy,
                        String attribute, DeviceData deviceData, String event_name) throws DevFailed {

        //  Check if address is coherent (??)
        deviceData = checkZmqAddress(deviceData, deviceProxy);

        String deviceName = deviceProxy.fullName();
        ApiUtil.printTrace("checkDeviceConnection for " + deviceName);
        if (!device_channel_map.containsKey(deviceName)) {
            ApiUtil.printTrace("    Does NOT Exist");
            connect(deviceProxy, attribute, event_name, deviceData);
            if (!device_channel_map.containsKey(deviceName)) {
                Except.throw_event_system_failed("API_NotificationServiceFailed",
                        "Failed to connect to event channel for device",
                        "EventConsumer.subscribe_event()");
            }
        }
        else {
            ApiUtil.printTrace(deviceName + " already connected.");
            ZMQutils.connectEvent(deviceProxy.get_tango_host(), deviceName,
                        attribute, deviceData.extractLongStringArray(), event_name,false);
        }
    }
467348
public int (final String a, final boolean fwd) throws DevFailed {
	final int rid = _i(a, fwd, next_req_id());
	arp.put(new Integer(rid), new Boolean(fwd));
	return rid;
    }
168674
protected void checkIfAlreadyConnected(DeviceProxy device, String attribute, String event_name, CallBack callback, int max_size, boolean stateless)
            throws DevFailed {
        if (device == null || (callback == null && max_size < 0)) {
            Except.throw_wrong_syntax_exception("API_InvalidArgs",
                    "Device or callback pointer NULL and  event queue not used !!",
                    "EventConsumer.subscribe_event()");
        }

        if (device == null || device.name() == null)
            Except.throw_event_system_failed("API_NotificationServiceFailed",
                    "Failed to connect to device",
                    "EventConsumer.subscribe_event()");
        else {
            //	Check if already connected (exists in map)
            String callback_key = device.name().toLowerCase() + "/" + attribute + "." + event_name;
            if (event_callback_map.containsKey(callback_key))
                Except.throw_event_system_failed("API_MethodArgument",
                        "Already connected to event " + callback_key,
                        "EventConsumer.subscribe_event()");

            //	Check if already trying to connects (exists in map)
            if (stateless && failed_event_callback_map.containsKey(callback_key))
                Except.throw_event_system_failed("API_MethodArgument",
                        "Already trying to connect to event " + callback_key,
                        "EventConsumer.subscribe_event()");
        }
    }
1274694
public void check_asynch_reply(final DeviceProxy deviceProxy, final Request request,
            final int id, final String idl_cmd) throws DevFailed {
        // Check if request object has been found
        if (request == null) {
            Except.throw_connection_failed("TangoApi_CommandFailed",
                "Asynchronous call id not found", deviceProxy.getFull_class_name() + "."
                    + idl_cmd + "_reply()");
        } else {
            if (!request.operation().equals(idl_cmd)) {
                Except.throw_connection_failed("TangoApi_CommandFailed",
                    "Asynchronous call id not for " + idl_cmd, deviceProxy.getFull_class_name()
                        + "." + idl_cmd + "_reply()");
            }

            // Reply arrived ? Throw exception if not yet arrived
            if (!request.poll_response()) {
                Except.throw_asyn_reply_not_arrived("API_AsynReplyNotArrived", "Device "
                    + deviceProxy.devname + ": reply for asynchronous call (id = " + id
                    + ") is not yet arrived", deviceProxy.getFull_class_name() + "." + idl_cmd
                    + "_reply()");
            } else {
                // Check if an exception has been thrown
                final Exception except = request.env().exception();

                if (except != null) {
                    ApiUtil.remove_async_request(id);
                    if (except instanceof org.omg.CORBA.TRANSIENT) {
                        throw_dev_failed(deviceProxy, except,
                                deviceProxy.getFull_class_name()
                                    + "." + idl_cmd + "_reply("
                                    + get_asynch_idl_cmd(deviceProxy, request, idl_cmd) + ")", false);
                    }
                    else
                    if (except instanceof org.omg.CORBA.TIMEOUT) {
                        throw_dev_failed(deviceProxy, except,
                                deviceProxy.getFull_class_name()
                                    + "." + idl_cmd + "_reply("
                                    + get_asynch_idl_cmd(deviceProxy, request, idl_cmd) + ")", false);
                    }
                    else
                    // Check if user exception (DevFailed).
                    if (except instanceof org.omg.CORBA.UnknownUserException) {
                        final Any any = ((org.omg.CORBA.UnknownUserException) except).except;
                        MultiDevFailed ex = null;
                        try {
                            //noinspection ThrowableResultOfMethodCallIgnored
                            ex = MultiDevFailedHelper.extract(any);
                        } catch (final Exception e) {
                            // not a MultiDevFailed, is a DevFailed
                            final DevFailed df = DevFailedHelper.extract(any);
                            Except.throw_connection_failed(df, "TangoApi_CommandFailed",
                                "Asynchronous command failed", deviceProxy.getFull_class_name()
                                    + "." + idl_cmd + "_reply("
                                    + get_asynch_idl_cmd(deviceProxy, request, idl_cmd)
                                    + ")");
                        }
                        if (ex!=null)
                            Except.throw_connection_failed(new DevFailed(
                                    ex.errors[0].err_list),
                                    "TangoApi_CommandFailed", "Asynchronous command failed",
                                    deviceProxy.getFull_class_name() + "." + idl_cmd + "_reply("
                                    + get_asynch_idl_cmd(deviceProxy, request, idl_cmd) + ")");
                    } else {
                        except.printStackTrace();
                        // Another exception -> re-throw it as a DevFailed
                        System.err.println(deviceProxy.getFull_class_name() + "." + idl_cmd
                            + "_reply(" + get_asynch_idl_cmd(deviceProxy, request, idl_cmd)
                            + ")");
                        throw_dev_failed(deviceProxy, except, deviceProxy.getFull_class_name()
                            + "." + idl_cmd + "_reply("
                            + get_asynch_idl_cmd(deviceProxy, request, idl_cmd) + ")", false);
                    }
                }
            }
        }
    }
1340276
public int subscribe_event(DeviceProxy device,
                               String attribute,
                               int event,
                               int max_size,
                               String[] filters,
                               boolean stateless)
            throws DevFailed {
        return subscribe_event(device, attribute, event, null, max_size, filters, stateless);
    }
880143
public DevState state(final DeviceProxy deviceProxy, final boolean src) throws DevFailed {

        build_connection(deviceProxy);

        if (deviceProxy.url.protocol == TANGO) {
            DevState state = DevState.UNKNOWN;
            final int retries = deviceProxy.transparent_reconnection ? 2 : 1;
            boolean done = false;
            for (int i = 0; i < retries && !done; i++) {
                try {
                    //noinspection PointlessBooleanExpression
                    if (src == ApiDefs.FROM_ATTR) {
                        state = deviceProxy.device.state();
                    } else {
                    final DeviceData argout = deviceProxy.command_inout("State");
                    state = argout.extractDevState();
                    }
                    done = true;
                } catch (final Exception e) {
                    manageExceptionReconnection(deviceProxy,
                            retries, i, e, this.getClass() + ".state");
                }
            }
            return state;
        } else {
            final DeviceData argout = command_inout(deviceProxy, "DevState");
            final short state = argout.extractShort();
            return T2Ttypes.tangoState(state);
        }
    }
1099173
public DevState getState() throws DevFailed {
        MDC.setContextMap(contextMap);
        xlogger.entry();
        if (isCorrectlyInit.get() && initImpl.isInitDoneCorrectly()) {
            state = stateImpl.updateState();
            // read all attributes to check alarms only if on
            if (state == DevState.ON && stateCheckAttrAlarm) {
                checkAlarms();
            }
        } else {
            state = stateImpl.getState();
        }
        return state;
    }
384350
public DevState updateState() throws DevFailed {
        xlogger.entry();
        Object getState;
        if (getStateMethod != null) {
            try {
                getState = getStateMethod.invoke(businessObject);
                if (getState != null) {
                    if (getState instanceof DeviceState) {
                        state = ((DeviceState) getState).getDevState();
                    } else {
                        state = (DevState) getState;
                    }
                }
            } catch (final IllegalArgumentException e) {
                throw DevFailedUtils.newDevFailed(e);
            } catch (final IllegalAccessException e) {
                throw DevFailedUtils.newDevFailed(e);
            } catch (final InvocationTargetException e) {
                if (e.getCause() instanceof DevFailed) {
                    throw (DevFailed) e.getCause();
                } else {
                    throw DevFailedUtils.newDevFailed(e.getCause());
                }
            }
        }
        //	if (!attributeAlarm.isEmpty()) {
        //	    state = DevState.ALARM;
        //	}
        xlogger.exit();
        return state;
    }
788413
public int subscribe_event(int event, CallBack callback, String[] filters) throws DevFailed {
        return dev.subscribe_event(deviceName, event, callback, filters);
    }
139742
@Init
    @StateMachine(endState = DeviceState.ON)
    public void init() throws DevFailed {
        xlogger.entry();
        TangoCacheManager.setPollSize(pollingThreadsPoolSize);
        // logger.debug("init admin device with quartzThreadsPoolSize = {}",
        // quartzThreadsPoolSize);
        status = "The device is ON\nThe polling is ON";
        tangoStats = TangoStats.getInstance();
        xlogger.exit();
    }
322399
@Command(name = STATE_NAME, outTypeDesc = "Device state")
    public DevState executeStateCmd() throws DevFailed {
        MDC.setContextMap(contextMap);
        xlogger.entry();
        xlogger.exit();
        return getState();
    }