Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  */
 
 package org.apache.airavata.ws.monitor;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 public class Monitor extends EventProducer {
 
     protected static final Logger logger = LoggerFactory.getLogger(Monitor.class);
 
     protected MonitorConfiguration configuration;
 
     protected static final String DEFAULT_MODEL_KEY = "_DEFAULT_MODEL_KEY";
 
 
     protected WsmgClient wsmgClient;
 
     protected boolean printRawMessages;
 
     protected long messagePullTimeout = 20000L;
 
     protected boolean monitoring = false;
     
     private boolean monitoringCompleted=false;
     
     private boolean monitoringFailed=false;
 
     
     public Monitor(MonitorConfiguration configuration) {
         this. = configuration;
         // First one keeps all event data & it doesn't have filters
         this..put(new EventDataRepository());
     }

    

Returns:
The configuration for monitoring
 
         return this.;
     }

    
Return the event data repository containing all the notifications

Returns:
 
         return this..get();
     }

    
Return the event data repository containing all the notifications for the node

Parameters:
nodeID
Returns:
 
         return this..get(nodeID);
     }

    
 
     public synchronized void start() throws MonitorException {
     	
     	//Make sure currently we are not doing any monitoring
        stop();
        // Reset monitoring variables
    	=false;
    	=false;
    	//Notify listeners that the monitoring is about to start
        subscribe();
        if (null != this..getInteractiveNodeIDs()) {
            List<StringinteractiveNodeIDs = this..getInteractiveNodeIDs();
            // now add models for this as well
            for (String string : interactiveNodeIDs) {
                final String nodeID = string;
                // for each wsnode there is one data model which
                this..put(nodeIDnew EventDataRepository(new EventFilter() {
                    public boolean isAcceptable(EventData event) {
                        return event != null && event.getNodeID() != null && event.getNodeID().equals(nodeID);
                    }
                }));
            }
        }
    }

    
Stops monitoring without using a thread.

    public synchronized void stop() throws MonitorException {
        try {
			if (this. != null) {
			    unsubscribe(this.);
			    this. = null;
			}
finally{
	        =true;
		}
    }

    
Start monitoring asynchronously
    public void startMonitoring(){
    	new Thread(){
    		@Override
    		public void run() {
    			try {
    				Monitor.this.start();
catch (MonitorException e) {
				}
    		}
    	}.start();
    }
    
    
Stop monitoring asynchronously
    public void stopMonitoring(){
    	// Users don't need to know the end of unsubscription.
        new Thread() {
            @Override
            public void run() {
                try {
                	Monitor.this.stop();
                } catch (WorkflowException e) {
                    // Ignore the error in unsubscription.
                    .error(e.getMessage(), e);
                }
            }
        }.start();
    }

    
Resets the graph and clear the monitoring table. Remove all the extra table models available
    public void resetEventData() {
        Set<Stringkeys = this..keySet();
        LinkedList<StringkeysToBeRemoved = new LinkedList<String>();
        // Remove everthing leaving only the last one
        for (String key : keys) {
            EventDataRepository monitorEventData = this..get(key);
            monitorEventData.removeAllEvents();
            if (!key.equals()) {
                keysToBeRemoved.add(key);
            }
        }
        for (String key : keysToBeRemoved) {
            this..remove(key);
        }
    }

    

Parameters:
event
    protected synchronized void handleNotification(XmlElement event) {
    	EventData eventData = new EventData(event);
    	if (eventData.getType()==.){
    	}
        Set<Stringkeys = this..keySet();
        // Remove everthing leaving only the last one
        if(){
            ..println(XMLUtil.xmlElementToString(event));
        }
        for (String key : keys) {
            this..get(key).addEvent(eventData);
        }
    }

    
Subscribe to the WS Messenger client to pull notifications from the message box

    private void subscribe() throws MonitorException {
        this. = new WsmgClient(this);
        //Users can set the timeout and interval for the subscription using wsmg setter methods, here we use the default values
        this..setTimeout(this.getMessagePullTimeout());
        this..subscribe();
        setMonitoring(true);
        // Enable/disable some menu items and show the monitor panel.
        sendSafeEvent(new Event(.));
    }

    
Unsubcribe from the ws messager client

Parameters:
client
Throws:
MonitorException
    private void unsubscribe(WsmgClient clientthrows MonitorException {
        // Enable/disable some menu items.
        sendSafeEvent(new Event(.));
        client.unsubscribe();
        setMonitoring(false);
    }
    
    
Wait until the monitoring is completed
    public void waitForCompletion(){
    		try {
				Thread.sleep(100);
catch (InterruptedException e) {
			}
    	}
    }
    
    
Print the raw notification messages to the console as they arrive

Parameters:
print - if true raw notifications are printed
    public void printRawMessage(boolean print){
    	this. = print;
    }
    
    
Retrieve the timeout in milliseconds for pulling messages

Returns:
    public long getMessagePullTimeout() {
        return ;
    }

    
Set the timeout in milliseconds for pulling messages

Parameters:
timeout
    public void setMessagePullTimeout(long timeout) {
        this. = timeout;
    }

    
is the monitoring active

Returns:
    public boolean isMonitoring() {
		return ;
    }
	}
    private void setMonitoring(boolean monitoring) {
        this. = monitoring;
    }
    
    
Return the id of the experiment which the monitoring is done

Returns:
    public String getExperimentId(){
    	return getConfiguration().getTopic();
    }
    
    

Deprecated:
- Use getEventDataRepository() instead
Returns:
    	return getEventDataRepository();
    }
    
    

Deprecated:
- Use getEventDataRepository(...) instead
Parameters:
nodeID
Returns:
    public EventDataRepository getEventData(String nodeID) {
        return getEventDataRepository(nodeID);
    }
    
    

Deprecated:
- Use printRawMessage(...) instead
Parameters:
print - if true raw notifications are printed
    public void setPrint(boolean print) {
        this. = print;
    }
New to GrepCode? Check out our FAQ X