End-to-End Example

Copy/**
 * Show full initialization flow for Context Service,
 * demonstrate a basic operation.
 */
public static void main(String ... args) {
    // Load our pre-created connection data
    String connectionData = ConnectionData.getConnectionData();

    // Initialize connector factory
    String pathToConnectorProperty = Paths.get("./connector.property").toAbsolutePath().toString();
    ConnectorFactory.initializeFactory(pathToConnectorProperty);
    LOGGER.info("Initialized Connector Factory");

    // Create Management connector instance
    ManagementConnector managementConnector = ConnectorFactory.getConnector(ManagementConnector.class);
    // Create Context Service Client instance
    ContextServiceClient contextServiceClient = ConnectorFactory.getConnector(ContextServiceClient.class);

    String hostname = "doctest.example.com";
    ConnectorInfoImpl connInfo = new ConnectorInfoImpl(hostname);
    ConnectorConfiguration configuration = new ConnectorConfiguration(){{
        addProperty("LAB_MODE", true); // exclude this line for production mode
        addProperty("REQUEST_TIMEOUT", 10000);

    }};

    // Add Management connector state listener. It needs to be done before calling init on the connector
    CustomConnectorStateListener mgmtConnectorStateListener = addStateListenerToMgmtConnector(managementConnector);
    // Add CredentialsChangedListener to Management connector. It needs to be added before calling init on the connector
    CredentialsChangedListener credentialsChangedListener = addCustomCredentialsListenerToManagementConnector(managementConnector,contextServiceClient);
    // Init Management connector
    managementConnector.init(connectionData, connInfo, configuration);
    // Now we can use the state listener to determine all the connector state changes
    try {
        waitForConnectorRegistered(mgmtConnectorStateListener, 3);
        LOGGER.info("Initialized Management connector");
    }catch(Exception e){
        LOGGER.error("Failed or timed out to initialize Management connector", e);
    }

    // Add Context Service Client connector state listener. It needs to be done before calling init on a connector
    CustomConnectorStateListener csConnectorStateListener = addStateListenerToContextConnector(contextServiceClient);

    // Init Context Service Client, reuse configuration we used for Management connector
    contextServiceClient.init(connectionData, connInfo, configuration);
    // Now we can use the state listener to determine all connector state changes
    try{
        waitForConnectorRegistered(csConnectorStateListener, 3);
        LOGGER.info("Initialized Context Service client");
    }catch(Exception e){
        LOGGER.error("Failed or timed out to initialize CS connector", e);
    }

    // Now we can use Context Service!
    // e.g. create a Pod:

    ContextObject pod = new ContextObject(ContextObject.Types.POD);

    pod.setDataElements(DataElementUtils.convertDataMapToSet(
            new HashMap<String, Object>() {{
                put("Context_Notes", "Context Service Demo POD");
                put("Context_POD_Activity_Link", "http://myservice.example.com/service/ID/xxxx");
            }}
    ));
    pod.setFieldsets(Arrays.asList("cisco.base.pod"));
    contextServiceClient.create(pod);
    LOGGER.info("Created Pod: " + pod.getId());

    // Do anything else you want to try here!
    // e.g. create data, update data, search for data

}
/**
 * Create a Custom Connector State Listener to override the stateChanged behavior
 */
public static class CustomConnectorStateListener implements ConnectorStateListener {
    public ConnectorState connectorState;

    public ConnectorState getConnectorState(){
        return connectorState;
    }

    @Override
    public void stateChanged(ConnectorState previousState, ConnectorState newState)
    {
        connectorState = newState;
        LOGGER.info("Connector state changed: " + newState);
        if (newState == ConnectorState.STOPPED) {
            // Perform optional cleanup tasks, etc ...
            LOGGER.info("Connector stopped.");
        }else if (newState == ConnectorState.REGISTERED) {
            // Perform any actions needed once connector is registered, etc ...
            LOGGER.info("Connector started.");
        } else if (newState == ConnectorState.UNREGISTERED) {
            // Perform any actions needed once connector is unregistered, etc ...
            LOGGER.info("Connector unregistered.");
        }
    }
}
/**
 * Before initializing the connector, create and add a ConnectorStateListener to the ContextServiceClient.
 * @param contextServiceClient
 * @return the created ConnectorStateListener
 */
public static CustomConnectorStateListener addStateListenerToContextConnector(ContextServiceClient contextServiceClient){
    CustomConnectorStateListener stateListener = new CustomConnectorStateListener();
    contextServiceClient.addStateListener(stateListener);
    return stateListener;
}
/**
 * Before initializing the connector, create and add a ConnectorStateListener to the Management Connector.
 * @param mgmtConnector
 * @return the created ConnectorStateListener
 */
public static CustomConnectorStateListener addStateListenerToMgmtConnector(ManagementConnector mgmtConnector){
    CustomConnectorStateListener stateListener = new CustomConnectorStateListener();
    mgmtConnector.addStateListener(stateListener);
    return stateListener;
}
/**
 * Wait timeoutSeconds for connector to be initialized, based on state listener callback
 * @param stateListener
 * @param timeoutSeconds
 */
public static void waitForConnectorRegistered(CustomConnectorStateListener stateListener, int timeoutSeconds) throws Exception{
    long startTime = System.currentTimeMillis();
    while((System.currentTimeMillis() - startTime) <= timeoutSeconds*1000 &&
            ConnectorState.REGISTERED.equals(stateListener.getConnectorState())){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    if(!ConnectorState.REGISTERED.equals(stateListener.getConnectorState())){
        throw new Exception("Timeout waiting for connector to register.");
    }
}