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.hadoop.hbase.master;
 
 import java.util.List;
 
 
 import java.util.List;

Provides the coprocessor framework and environment for master oriented operations. HMaster interacts with the loaded coprocessors through this class.
 
 public class MasterCoprocessorHost
 
   private static final Log LOG = LogFactory.getLog(MasterCoprocessorHost.class);

  
Coprocessor environment extension providing access to master related services.
 
   static class MasterEnvironment extends CoprocessorHost.Environment
       implements MasterCoprocessorEnvironment {
     private MasterServices masterServices;
 
     public MasterEnvironment(final Class<?> implClassfinal Coprocessor impl,
         final int priorityfinal int seqfinal Configuration conf,
         final MasterServices services) {
       super(implpriorityseqconf);
       this. = services;
     }
 
     public MasterServices getMasterServices() {
       return ;
     }
   }
 
 
   public MasterCoprocessorHost(final MasterServices servicesfinal Configuration conf) {
     super(services);
     this. = conf;
     this. = services;
     // Log the state of coprocessor loading here; should appear only once or
     // twice in the daemon log, depending on HBase version, because there is
     // only one MasterCoprocessorHost instance in the master process
     boolean coprocessorsEnabled = conf.getBoolean(,
     .info("System coprocessor loading is " + (coprocessorsEnabled ? "enabled" : "disabled"));
   }
 
   @Override
   public MasterEnvironment createEnvironment(final Class<?> implClass,
       final Coprocessor instancefinal int priorityfinal int seq,
       final Configuration conf) {
     for (Class<?> c : implClass.getInterfaces()) {
       if (CoprocessorService.class.isAssignableFrom(c)) {
       }
     }
     return new MasterEnvironment(implClassinstancepriorityseqconf,
         );
   }
  public boolean preCreateNamespace(final NamespaceDescriptor nsthrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preCreateNamespace(ctxns);
      }
    });
  }
  public void postCreateNamespace(final NamespaceDescriptor nsthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postCreateNamespace(ctxns);
      }
    });
  }
  public boolean preDeleteNamespace(final String namespaceNamethrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDeleteNamespace(ctxnamespaceName);
      }
    });
  }
  public void postDeleteNamespace(final String namespaceNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDeleteNamespace(ctxnamespaceName);
      }
    });
  }
  public boolean preModifyNamespace(final NamespaceDescriptor nsthrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preModifyNamespace(ctxns);
      }
    });
  }
  public void postModifyNamespace(final NamespaceDescriptor nsthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postModifyNamespace(ctxns);
      }
    });
  }
  /* Implementation of hooks for invoking MasterObservers */
  public void preCreateTable(final HTableDescriptor htdfinal HRegionInfo[] regions)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preCreateTable(ctxhtdregions);
      }
    });
  }
  public void postCreateTable(final HTableDescriptor htdfinal HRegionInfo[] regions)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postCreateTable(ctxhtdregions);
      }
    });
  }
  public void preCreateTableHandler(final HTableDescriptor htdfinal HRegionInfo[] regions)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preCreateTableHandler(ctxhtdregions);
      }
    });
  }
  public void postCreateTableHandler(final HTableDescriptor htdfinal HRegionInfo[] regions)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postCreateTableHandler(ctxhtdregions);
      }
    });
  }
  public void preDeleteTable(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDeleteTable(ctxtableName);
      }
    });
  }
  public void postDeleteTable(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDeleteTable(ctxtableName);
      }
    });
  }
  public void preDeleteTableHandler(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDeleteTableHandler(ctxtableName);
      }
    });
  }
  public void postDeleteTableHandler(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDeleteTableHandler(ctxtableName);
      }
    });
  }
  public void preTruncateTable(TableName tableNamethrows IOException {
    for (MasterEnvironment env) {
      if (env.getInstance() instanceof MasterObserver) {
        ctx = ObserverContext.createAndPrepare(envctx);
        try {
          ((MasterObserver)env.getInstance()).preTruncateTable(ctxtableName);
        } catch (Throwable e) {
          handleCoprocessorThrowable(enve);
        }
        if (ctx.shouldComplete()) {
          break;
        }
      }
    }
  }
  public void postTruncateTable(TableName tableNamethrows IOException {
    for (MasterEnvironment env) {
      if (env.getInstance() instanceof MasterObserver) {
        ctx = ObserverContext.createAndPrepare(envctx);
        try {
          ((MasterObserver)env.getInstance()).postTruncateTable(ctxtableName);
        } catch (Throwable e) {
          handleCoprocessorThrowable(enve);
        }
        if (ctx.shouldComplete()) {
          break;
        }
      }
    }
  }
  public void preTruncateTableHandler(TableName tableNamethrows IOException {
    for (MasterEnvironment env : ) {
      if (env.getInstance() instanceof MasterObserver) {
        ctx = ObserverContext.createAndPrepare(envctx);
        try {
          ((MasterObserverenv.getInstance()).preTruncateTableHandler(ctxtableName);
        } catch (Throwable e) {
          handleCoprocessorThrowable(enve);
        }
        if (ctx.shouldComplete()) {
          break;
        }
      }
    }
  }
  public void postTruncateTableHandler(TableName tableNamethrows IOException {
    for (MasterEnvironment env : ) {
      if (env.getInstance() instanceof MasterObserver) {
        ctx = ObserverContext.createAndPrepare(envctx);
        try {
          ((MasterObserverenv.getInstance()).postTruncateTableHandler(ctxtableName);
        } catch (Throwable e) {
          handleCoprocessorThrowable(enve);
        }
        if (ctx.shouldComplete()) {
          break;
        }
      }
    }
  }
  public void preModifyTable(final TableName tableNamefinal HTableDescriptor htd)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preModifyTable(ctxtableNamehtd);
      }
    });
  }
  public void postModifyTable(final TableName tableNamefinal HTableDescriptor htd)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postModifyTable(ctxtableNamehtd);
      }
    });
  }
  public void preModifyTableHandler(final TableName tableNamefinal HTableDescriptor htd)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preModifyTableHandler(ctxtableNamehtd);
      }
    });
  }
  public void postModifyTableHandler(final TableName tableNamefinal HTableDescriptor htd)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postModifyTableHandler(ctxtableNamehtd);
      }
    });
  }
  public boolean preAddColumn(final TableName tableNamefinal HColumnDescriptor column)
      throws IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preAddColumn(ctxtableNamecolumn);
      }
    });
  }
  public void postAddColumn(final TableName tableNamefinal HColumnDescriptor column)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postAddColumn(ctxtableNamecolumn);
      }
    });
  }
  public boolean preAddColumnHandler(final TableName tableNamefinal HColumnDescriptor column)
      throws IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preAddColumnHandler(ctxtableNamecolumn);
      }
    });
  }
  public void postAddColumnHandler(final TableName tableNamefinal HColumnDescriptor column)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postAddColumnHandler(ctxtableNamecolumn);
      }
    });
  }
  public boolean preModifyColumn(final TableName tableNamefinal HColumnDescriptor descriptor)
      throws IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preModifyColumn(ctxtableNamedescriptor);
      }
    });
  }
  public void postModifyColumn(final TableName tableNamefinal HColumnDescriptor descriptor)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postModifyColumn(ctxtableNamedescriptor);
      }
    });
  }
  public boolean preModifyColumnHandler(final TableName tableName,
      final HColumnDescriptor descriptorthrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preModifyColumnHandler(ctxtableNamedescriptor);
      }
    });
  }
  public void postModifyColumnHandler(final TableName tableName,
      final HColumnDescriptor descriptorthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postModifyColumnHandler(ctxtableNamedescriptor);
      }
    });
  }
  public boolean preDeleteColumn(final TableName tableNamefinal byte [] cthrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDeleteColumn(ctxtableNamec);
      }
    });
  }
  public void postDeleteColumn(final TableName tableNamefinal byte [] cthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDeleteColumn(ctxtableNamec);
      }
    });
  }
  public boolean preDeleteColumnHandler(final TableName tableNamefinal byte[] c)
      throws IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDeleteColumnHandler(ctxtableNamec);
      }
    });
  }
  public void postDeleteColumnHandler(final TableName tableNamefinal byte[] c)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDeleteColumnHandler(ctxtableNamec);
      }
    });
  }
  public void preEnableTable(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preEnableTable(ctxtableName);
      }
    });
  }
  public void postEnableTable(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postEnableTable(ctxtableName);
      }
    });
  }
  public void preEnableTableHandler(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preEnableTableHandler(ctxtableName);
      }
    });
  }
  public void postEnableTableHandler(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postEnableTableHandler(ctxtableName);
      }
    });
  }
  public void preDisableTable(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDisableTable(ctxtableName);
      }
    });
  }
  public void postDisableTable(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDisableTable(ctxtableName);
      }
    });
  }
  public void preDisableTableHandler(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDisableTableHandler(ctxtableName);
      }
    });
  }
  public void postDisableTableHandler(final TableName tableNamethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDisableTableHandler(ctxtableName);
      }
    });
  }
  public boolean preMove(final HRegionInfo regionfinal ServerName srcServer,
      final ServerName destServerthrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preMove(ctxregionsrcServerdestServer);
      }
    });
  }
  public void postMove(final HRegionInfo regionfinal ServerName srcServer,
      final ServerName destServerthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postMove(ctxregionsrcServerdestServer);
      }
    });
  }
  public boolean preAssign(final HRegionInfo regionInfothrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preAssign(ctxregionInfo);
      }
    });
  }
  public void postAssign(final HRegionInfo regionInfothrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postAssign(ctxregionInfo);
      }
    });
  }
  public boolean preUnassign(final HRegionInfo regionInfofinal boolean force)
      throws IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preUnassign(ctxregionInfoforce);
      }
    });
  }
  public void postUnassign(final HRegionInfo regionInfofinal boolean forcethrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postUnassign(ctxregionInfoforce);
      }
    });
  }
  public void preRegionOffline(final HRegionInfo regionInfothrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preRegionOffline(ctxregionInfo);
      }
    });
  }
  public void postRegionOffline(final HRegionInfo regionInfothrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postRegionOffline(ctxregionInfo);
      }
    });
  }
  public boolean preBalance() throws IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preBalance(ctx);
      }
    });
  }
  public void postBalance(final List<RegionPlanplansthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postBalance(ctxplans);
      }
    });
  }
  public boolean preBalanceSwitch(final boolean bthrows IOException {
    return execOperationWithResult(b.isEmpty() ? null :
        new CoprocessorOperationWithResult<Boolean>() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        setResult(oserver.preBalanceSwitch(ctxgetResult()));
      }
    });
  }
  public void postBalanceSwitch(final boolean oldValuefinal boolean newValue)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postBalanceSwitch(ctxoldValuenewValue);
      }
    });
  }
  public void preShutdown() throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preShutdown(ctx);
      }
      @Override
      public void postEnvCall(MasterEnvironment env) {
        // invoke coprocessor stop method
        shutdown(env);
      }
    });
  }
  public void preStopMaster() throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preStopMaster(ctx);
      }
      @Override
      public void postEnvCall(MasterEnvironment env) {
        // invoke coprocessor stop method
        shutdown(env);
      }
    });
  }
  public void preMasterInitialization() throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preMasterInitialization(ctx);
      }
    });
  }
  public void postStartMaster() throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postStartMaster(ctx);
      }
    });
  }
  public void preSnapshot(final SnapshotDescription snapshot,
      final HTableDescriptor hTableDescriptorthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preSnapshot(ctxsnapshothTableDescriptor);
      }
    });
  }
  public void postSnapshot(final SnapshotDescription snapshot,
      final HTableDescriptor hTableDescriptorthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postSnapshot(ctxsnapshothTableDescriptor);
      }
    });
  }
  public void preCloneSnapshot(final SnapshotDescription snapshot,
      final HTableDescriptor hTableDescriptorthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preCloneSnapshot(ctxsnapshothTableDescriptor);
      }
    });
  }
  public void postCloneSnapshot(final SnapshotDescription snapshot,
      final HTableDescriptor hTableDescriptorthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postCloneSnapshot(ctxsnapshothTableDescriptor);
      }
    });
  }
  public void preRestoreSnapshot(final SnapshotDescription snapshot,
      final HTableDescriptor hTableDescriptorthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preRestoreSnapshot(ctxsnapshothTableDescriptor);
      }
    });
  }
  public void postRestoreSnapshot(final SnapshotDescription snapshot,
      final HTableDescriptor hTableDescriptorthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postRestoreSnapshot(ctxsnapshothTableDescriptor);
      }
    });
  }
  public void preDeleteSnapshot(final SnapshotDescription snapshotthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preDeleteSnapshot(ctxsnapshot);
      }
    });
  }
  public void postDeleteSnapshot(final SnapshotDescription snapshotthrows IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postDeleteSnapshot(ctxsnapshot);
      }
    });
  }
  public boolean preGetTableDescriptors(final List<TableNametableNamesList,
      final List<HTableDescriptordescriptorsthrows IOException {
    return execOperation(.isEmpty() ? null : new CoprocessorOperation() {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.preGetTableDescriptors(ctxtableNamesListdescriptors);
      }
    });
  }
  public void postGetTableDescriptors(final List<HTableDescriptordescriptors)
      throws IOException {
      @Override
      public void call(MasterObserver oserverObserverContext<MasterCoprocessorEnvironmentctx)
          throws IOException {
        oserver.postGetTableDescriptors(ctxdescriptors);
      }
    });
  }
  private static abstract class CoprocessorOperation
    public CoprocessorOperation() {
    }
    public abstract void call(MasterObserver oserver,
    public void postEnvCall(MasterEnvironment env) {
    }
  }
  private static abstract class CoprocessorOperationWithResult<T> extends CoprocessorOperation {
    private T result = null;
    public void setResult(final T result) { this. = result; }
    public T getResult() { return this.; }
  }
  private <T> T execOperationWithResult(final T defaultValue,
      final CoprocessorOperationWithResult<T> ctxthrows IOException {
    if (ctx == nullreturn defaultValue;
    ctx.setResult(defaultValue);
    execOperation(ctx);
    return ctx.getResult();
  }
  private boolean execOperation(final CoprocessorOperation ctxthrows IOException {
    if (ctx == nullreturn false;
    boolean bypass = false;
    for (MasterEnvironment env) {
      if (env.getInstance() instanceof MasterObserver) {
        ctx.prepare(env);
        Thread currentThread = Thread.currentThread();
        ClassLoader cl = currentThread.getContextClassLoader();
        try {
          currentThread.setContextClassLoader(env.getClassLoader());
          ctx.call((MasterObserver)env.getInstance(), ctx);
        } catch (Throwable e) {
          handleCoprocessorThrowable(enve);
        } finally {
          currentThread.setContextClassLoader(cl);
        }
        bypass |= ctx.shouldBypass();
        if (ctx.shouldComplete()) {
          break;
        }
      }
      ctx.postEnvCall(env);
    }
    return bypass;
  }