OperationWatchdog.java

/**
 * Copyright 2008 the original author or authors.
 *
 * Licensed 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 net.sf.katta.master;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import net.sf.katta.operation.OperationId;
import net.sf.katta.operation.master.MasterOperation;
import net.sf.katta.operation.node.OperationResult;
import net.sf.katta.protocol.ConnectedComponent;
import net.sf.katta.protocol.IAddRemoveListener;
import net.sf.katta.protocol.InteractionProtocol;
import net.sf.katta.util.ZkConfiguration.PathDef;

import org.I0Itec.zkclient.IZkDataListener;
import org.apache.log4j.Logger;

/**
 * When watchdog for a list of {@link NodeOperation}s. The watchdog is finished
 * if all operations are done or the nodes of the incomplete nodes went down.
 */
public class OperationWatchdog implements ConnectedComponent, Serializable {

  private static final long serialVersionUID = 1L;
  protected final static Logger LOG = Logger.getLogger(OperationWatchdog.class);

  private final String _queueElementId;
  private final List<OperationId> _openOperationIds;
  private final List<OperationId> _operationIds;
  private MasterContext _context;
  private final MasterOperation _masterOperation;

  public OperationWatchdog(String queueElementId, MasterOperation masterOperation, List<OperationId> operationIds) {
    _queueElementId = queueElementId;
    _operationIds = operationIds;
    _masterOperation = masterOperation;
    _openOperationIds = new ArrayList<OperationId>(operationIds);
  }

  public void start(MasterContext context) {
    _context = context;
    subscribeNotifications();
  }

  private final synchronized void subscribeNotifications() {
    checkDeploymentForCompletion();
    if (isDone()) {
      return;
    }

    InteractionProtocol protocol = _context.getProtocol();
    protocol.registerChildListener(this, PathDef.NODES_LIVE, new IAddRemoveListener() {
      @Override
      public void removed(String name) {
        checkDeploymentForCompletion();
      }

      @Override
      public void added(String name) {
        // nothing todo
      }
    });
    IZkDataListener dataListener = new IZkDataListener() {
      @Override
      public void handleDataDeleted(String arg0) throws Exception {
        checkDeploymentForCompletion();
      }

      @Override
      public void handleDataChange(String arg0, Object arg1) throws Exception {
        // nothing todo
      }
    };
    for (OperationId operationId : _openOperationIds) {
      protocol.registerNodeOperationListener(this, operationId, dataListener);
    }
    checkDeploymentForCompletion();
  }

  protected final synchronized void checkDeploymentForCompletion() {
    if (isDone()) {
      return;
    }

    List<String> liveNodes = _context.getProtocol().getLiveNodes();
    for (Iterator<OperationId> iter = _openOperationIds.iterator(); iter.hasNext();) {
      OperationId operationId = iter.next();
      if (!_context.getProtocol().isNodeOperationQueued(operationId) || !liveNodes.contains(operationId.getNodeName())) {
        iter.remove();
      }
    }
    if (isDone()) {
      finishWatchdog();
    } else {
      LOG.debug("still " + getOpenOperationCount() + " open deploy operations");
    }
  }

  public synchronized void cancel() {
    _context.getProtocol().unregisterComponent(this);
    this.notifyAll();
  }

  private synchronized void finishWatchdog() {
    InteractionProtocol protocol = _context.getProtocol();
    protocol.unregisterComponent(this);
    try {
      List<OperationResult> operationResults = new ArrayList<OperationResult>(_openOperationIds.size());
      for (OperationId operationId : _operationIds) {
        OperationResult operationResult = protocol.getNodeOperationResult(operationId, true);
        if (operationResult != null && operationResult.getUnhandledException() != null) {
          // TODO jz: do we need to inform the master operation ?
          LOG.error("received unhandlde exception from node " + operationId.getNodeName(), operationResult
                  .getUnhandledException());
        }
        operationResults.add(operationResult);// we add null ones
      }
      _masterOperation.nodeOperationsComplete(_context, operationResults);
    } catch (Exception e) {
      LOG.info("operation complete action of " + _masterOperation + " failed", e);
    }
    LOG.info("watch for " + _masterOperation + " finished");
    this.notifyAll();
    _context.getMasterQueue().removeWatchdog(this);
  }

  public String getQueueElementId() {
    return _queueElementId;
  }

  public MasterOperation getOperation() {
    return _masterOperation;
  }

  public List<OperationId> getOperationIds() {
    return _operationIds;
  }

  public final int getOpenOperationCount() {
    return _openOperationIds.size();
  }

  public boolean isDone() {
    return _openOperationIds.isEmpty();
  }

  public final synchronized void join() throws InterruptedException {
    join(0);
  }

  public final synchronized void join(long timeout) throws InterruptedException {
    if (!isDone()) {
      this.wait(timeout);
    }
  }

  @Override
  public final void disconnect() {
    // handled by master
  }

  @Override
  public final void reconnect() {
    // handled by master
  }

}