示例#1
0
    private void postActionHook() {
      if (LOG.isTraceEnabled()) {
        LOG.trace("postActionHook()...  Task: " + mAction.getName() + "has completed");
      }

      persistActionRecord();

      // Check if the initiator of this action supports scoring...
      Object initiator = mContext.getMapObjectCollection().getObjectByGuid(mAction.getInitiator());
      if (initiator instanceof IScoringAbility) {
        ((IScoringAbility) initiator).score(mAction);
      }
    }
 public void process(WatchedEvent event) {
   if (event.getType() == Event.EventType.NodeChildrenChanged) {
     LOG.debug("Running children changed [" + event.getPath() + "]");
     try {
       getZkRunning();
     } catch (Exception e) {
       e.printStackTrace();
       LOG.error(e);
     }
   } else if (event.getType() == Event.EventType.NodeDeleted) {
     String znodePath = event.getPath();
     LOG.debug("Running znode deleted [" + znodePath + "]");
     try {
       restartServer(znodePath);
     } catch (Exception e) {
       e.printStackTrace();
       LOG.error(e);
     }
   }
 }
 ReadAccessToken(boolean explicit) {
   myExplicit = explicit;
   LOG.assertTrue(
       !Thread.holdsLock(PsiLock.LOCK),
       "Thread must not hold PsiLock while performing readAction");
   try {
     myActionsLock.readLock().acquire();
     if (myExplicit) acquired();
   } catch (InterruptedException e) {
     throw new RuntimeInterruptedException(e);
   }
 }
示例#4
0
    @Override
    public void run() {
      try {
        if (myDisposed) {
          return;
        }
        synchronized (LOCK) {
          if (myTask == null) return;
        }

        final Runnable scheduledTask =
            new Runnable() {
              @Override
              public void run() {
                final Runnable task;
                synchronized (LOCK) {
                  task = myTask;
                  if (task == null) return;
                  myTask = null;

                  myRequests.remove(Request.this);
                }

                if (myThreadToUse == ThreadToUse.SWING_THREAD && !isEdt()) {
                  try {
                    SwingUtilities.invokeAndWait(task);
                  } catch (Exception e) {
                    LOG.error(e);
                  }
                } else {
                  try {
                    task.run();
                  } catch (Exception e) {
                    LOG.error(e);
                  }
                }
              }
            };

        if (myModalityState == null) {
          myFuture = myExecutorService.submit(scheduledTask);
        } else {
          final Application app = ApplicationManager.getApplication();
          if (app != null) {
            app.invokeLater(scheduledTask, myModalityState);
          } else {
            SwingUtilities.invokeLater(scheduledTask);
          }
        }
      } catch (Throwable e) {
        LOG.error(e);
      }
    }
    public WriteAccessToken(Class _clazz) {
      clazz = _clazz;
      assertCanRunWriteAction();

      ActivityTracker.getInstance().inc();
      fireBeforeWriteActionStart(_clazz);
      final AtomicBoolean stopped = new AtomicBoolean(false);

      if (ourDumpThreadsOnLongWriteActionWaiting > 0) {
        executeOnPooledThread(
            new Runnable() {
              @Override
              public void run() {
                while (!stopped.get()) {
                  try {
                    Thread.sleep(ourDumpThreadsOnLongWriteActionWaiting);
                    if (!stopped.get()) {
                      PerformanceWatcher.getInstance().dumpThreads(true);
                    }
                  } catch (InterruptedException ignored) {
                  }
                }
              }
            });
      }

      LOG.assertTrue(
          myActionsLock.isWriteLockAcquired(Thread.currentThread())
              || !Thread.holdsLock(PsiLock.LOCK),
          "Thread must not hold PsiLock while performing writeAction");
      try {
        myActionsLock.writeLock().acquire();
        acquired();
      } catch (InterruptedException e) {
        throw new RuntimeInterruptedException(e);
      }
      stopped.set(true);

      myWriteActionsStack.push(_clazz);

      fireWriteActionStarted(_clazz);
    }
示例#6
0
    /**
     * The actual wrapped call. Note that all of the action's execution method is wrapped in a
     * try/catch block, so that we can contain any explosive exceptions that occur during operation.
     */
    public String call() throws Exception {
      /*
       * Perform pre-action checks to verify that the initiators and
       * receivers support the action's required IAbilities
       */

      if (!preActionHook()) {
        persistActionRecord();
        return mResult;
      }

      try {
        mAction.preActionHook();
        mResult = mAction.executeCallableAction();
        mAction.postActionHook();
      } catch (Exception e) {
        LOG.error(
            "Exception occured while attempting to perform PreActionHook for action:"
                + e.getLocalizedMessage());
        mResult = "FAILED: EXCEPTION " + e.getLocalizedMessage();
      }
      /*
       * If this is a repeating task, schedule the future task at the
       * appropriate period. Note that we are carrying forward the same
       * mAction, so that internal changes to the action object will have
       * continuity over their entire lifetime.
       *
       * Calling get() or any other waiting block will only work for the
       * first iteration of the task, because the caller would have a
       * reference to the first of many possible ScheduledFuture's... this
       * is alright, because the IAction's behavior is still the same as
       * if it were submitted normally, the Future that the caller got
       * still behaves as if the task were running periodically. No loss
       * for them...
       */
      if (mAction.getPeriod() > 0) {
        mAction.schedule(mAction.getPeriod(), mAction.getTimeUnit());
      }
      postActionHook();
      persistActionRecord();
      return mResult;
    }
示例#7
0
    private boolean preActionHook() {
      if (LOG.isTraceEnabled()) {
        LOG.trace("preActionHook()...  Task: " + mAction.getName() + "starting");
      }

      /*
       * If this action was started by the SYSTEM_GUID, we don't do any
       * ability checking on the operation. We may want to expand this out
       * later to include different processes with different abilities,
       * but for now, let's just let the system do anything it wants.
       */
      if (!GuidManager.SYSTEM_GUID.equals(mAction.getInitiator())) {
        Object initiator =
            mContext.getMapObjectCollection().getObjectByGuid(mAction.getInitiator());
        if (initiator == null) {
          initiator = mContext.getRegionCollection().getRegion(mAction.getInitiator());
          if (null == initiator) {
            LOG.warn("Command action using the system guid...was this expected?");
          }
        }

        //  TODO:  This check may not be appropriate here.... How about AI objects?  Moving Zones?
        if (!(initiator instanceof IMapObject) && !(initiator instanceof IMapRegion)) {
          mResult = "FAIL: Initiator is not an IMapObject or IMapRegion";
          return false;
        }

        // Now verify that the initiator supports all of the IAction's
        // required abilities
        if (!supportsRequiredAbilities(
            mAction.getRequiredInitiatorAbilities(), ((IAbility) initiator).getObjectAbilities())) {
          mResult = "FAIL: Initiator doesn't support one of the required IAbilities";
          return false;
        }
      }

      /*
       * Now walk each of the receivers, verifying that they support all
       * of the required methods necessary to support the action. But,
       * recievers might not be in the trackableByGuidList. atm I am
       * trying to use a record that does implement the IAction And if it
       * is the system, just return.
       */
      Iterator<Long> itor = mAction.getReceiver().iterator();
      while (itor.hasNext()) {
        // Verify first that this receiver supports IAbility
        long next = itor.next();
        // if system, then continue to next itoration
        if (next == GuidManager.SYSTEM_GUID) {
          continue;
        }
        Object receiver = mContext.getMapObjectCollection().getObjectByGuid(next);

        // The recever might be found int the
        // m_context.getPlayerSignUpActionCollection.get(next);
        //                if (receiver == null)
        //                    receiver = m_context.getPlayerSignUpActionHashtable().get(next);

        if (!(receiver instanceof IAbility)) {
          mResult = "FAIL: Receiver doesn't support IAbility";
          return false;
        }

        // Now verify that the receiver supports all of the IAction's
        // required abilities
        if (!supportsRequiredAbilities(
            mAction.getRequiredReceiverAbilities(), ((IAbility) receiver).getObjectAbilities())) {
          mResult = "FAIL: Receiver doesn't support one of the required IAbilities";
          return false;
        }
      }
      return true;
    }
    @Override
    public ScriptContext call() throws Exception {
      try {
        Scanner scn = new Scanner(znodePath);
        scn.useDelimiter(":");
        String hostName = scn.next(); // host name
        String instance = scn.next(); // instance
        int infoPort = Integer.parseInt(scn.next()); // UI info port
        long serverStartTimestamp = Long.parseLong(scn.next());
        scn.close();

        // Get the --config property from classpath...it's always first
        // in the classpath
        String cp = System.getProperty("java.class.path");
        scn = new Scanner(cp);
        scn.useDelimiter(":");
        String confDir = scn.next();
        scn.close();
        LOG.debug("conf dir [" + confDir + "]");

        // Get -Dwms.home.dir
        String wmsHome = System.getProperty("wms.home.dir");

        // If stop-wms.sh is executed and WMS_MANAGES_ZK then zookeeper
        // is stopped abruptly.
        // Second scenario is when ZooKeeper fails for some reason
        // regardless of whether WMS
        // manages it. When either happens the WmsServer running znodes
        // still exist in ZooKeeper
        // and we see them at next startup. When they eventually timeout
        // we get node deleted events for a server that no longer
        // exists. So, only recognize
        // WmsServer running znodes that have timestamps after last
        // WmsMaster startup.
        if (serverStartTimestamp > startupTimestamp) {
          scriptContext.setHostName(hostName);
          scriptContext.setScriptName("sys_shell.py");
          if (hostName.equalsIgnoreCase(ia.getCanonicalHostName()))
            scriptContext.setCommand(
                "bin/wms-daemon.sh --config " + confDir + " start server " + instance);
          else
            scriptContext.setCommand(
                "pdsh -w "
                    + hostName
                    + " \"cd "
                    + wmsHome
                    + ";bin/wms-daemon.sh --config "
                    + confDir
                    + " start server "
                    + instance
                    + "\"");

          RetryCounter retryCounter = retryCounterFactory.create();
          while (true) {
            if (scriptContext.getStdOut().length() > 0)
              scriptContext.getStdOut().delete(0, scriptContext.getStdOut().length());
            if (scriptContext.getStdErr().length() > 0)
              scriptContext.getStdErr().delete(0, scriptContext.getStdErr().length());
            LOG.info(
                "Restarting WmsServer ["
                    + hostName
                    + ":"
                    + instance
                    + "], script [ "
                    + scriptContext.toString()
                    + " ]");
            ScriptManager.getInstance().runScript(scriptContext);

            if (scriptContext.getExitCode() == 0) {
              LOG.info("WmsServer [" + hostName + ":" + instance + "] restarted");
              break;
            } else {
              StringBuilder sb = new StringBuilder();
              sb.append("exit code [" + scriptContext.getExitCode() + "]");
              if (!scriptContext.getStdOut().toString().isEmpty())
                sb.append(", stdout [" + scriptContext.getStdOut().toString() + "]");
              if (!scriptContext.getStdErr().toString().isEmpty())
                sb.append(", stderr [" + scriptContext.getStdErr().toString() + "]");
              LOG.error(sb.toString());

              if (!retryCounter.shouldRetry()) {
                LOG.error(
                    "WmsServer ["
                        + hostName
                        + ":"
                        + instance
                        + "] restart failed after "
                        + retryCounter.getMaxRetries()
                        + " retries");
                break;
              } else {
                retryCounter.sleepUntilNextRetry();
                retryCounter.useRetry();
              }
            }
          }
        } else {
          LOG.debug(
              "No restart for "
                  + znodePath
                  + "\nbecause WmsServer start time ["
                  + DateFormat.getDateTimeInstance().format(new Date(serverStartTimestamp))
                  + "] was before WmsMaster start time ["
                  + DateFormat.getDateTimeInstance().format(new Date(startupTimestamp))
                  + "]");
        }
      } catch (Exception e) {
        e.printStackTrace();
        LOG.error(e);
      }

      return scriptContext;
    }
示例#9
0
 private void runAThread(ThreadedEntityProcessorWrapper epw, EntityRow rows, String currProcess)
     throws Exception {
   currentEntityProcWrapper.set(epw);
   epw.threadedInit(context);
   initEntity();
   try {
     epw.init(rows);
     DocWrapper docWrapper = this.docWrapper;
     Context.CURRENT_CONTEXT.set(context);
     for (; ; ) {
       if (DocBuilder.this.stop.get()) break;
       try {
         Map<String, Object> arow = epw.nextRow();
         if (arow == null) {
           break;
         } else {
           importStatistics.rowsCount.incrementAndGet();
           if (docWrapper == null && entity.isDocRoot) {
             docWrapper = new DocWrapper();
             context.setDoc(docWrapper);
             DataConfig.Entity e = entity.parentEntity;
             for (EntityRow row = rows;
                 row != null && e != null;
                 row = row.tail, e = e.parentEntity) {
               addFields(e, docWrapper, row.row, epw.resolver);
             }
           }
           if (docWrapper != null) {
             handleSpecialCommands(arow, docWrapper);
             addFields(entity, docWrapper, arow, epw.resolver);
           }
           if (entity.entities != null) {
             EntityRow nextRow = new EntityRow(arow, rows, entity.name);
             for (DataConfig.Entity e : entity.entities) {
               epw.children.get(e).run(docWrapper, currProcess, nextRow);
             }
           }
         }
         if (entity.isDocRoot) {
           LOG.info("a row on docroot" + docWrapper);
           if (!docWrapper.isEmpty()) {
             LOG.info("adding a doc " + docWrapper);
             boolean result = writer.upload(docWrapper);
             docWrapper = null;
             if (result) {
               importStatistics.docCount.incrementAndGet();
             } else {
               importStatistics.failedDocCount.incrementAndGet();
             }
           }
         }
       } catch (DataImportHandlerException dihe) {
         exception = dihe;
         if (dihe.getErrCode() == SKIP_ROW || dihe.getErrCode() == SKIP) {
           importStatistics.skipDocCount.getAndIncrement();
           exception = null; // should not propogate up
           continue;
         }
         if (entity.isDocRoot) {
           if (dihe.getErrCode() == DataImportHandlerException.SKIP) {
             importStatistics.skipDocCount.getAndIncrement();
             exception = null; // should not propogate up
           } else {
             LOG.error(
                 "Exception while processing: " + entity.name + " document : " + docWrapper,
                 dihe);
           }
           if (dihe.getErrCode() == DataImportHandlerException.SEVERE) throw dihe;
         } else {
           // if this is not the docRoot then the execution has happened in the same thread. so
           // propogate up,
           // it will be handled at the docroot
           entityEnded.set(true);
           throw dihe;
         }
         entityEnded.set(true);
       }
     }
   } finally {
     epw.destroy();
     currentEntityProcWrapper.remove();
     Context.CURRENT_CONTEXT.remove();
   }
 }