private void resetState() {
   connectLatch.drainPermits();
   abandonLatch.drainPermits();
   bindLatch.drainPermits();
   searchLatch.drainPermits();
   closeLatch.drainPermits();
   context.set(null);
   serverConnection = mock(ServerConnection.class);
 }
  /** Run the bollie thread */
  @Override
  public void run() {
    golfBall[] ballsCollected; // Array to hold the balls bollie collects
    while (done.get() != true) { // Check that Range has not closed
      try {
        sleep(waitTime.nextInt(5000) + 2000); // Sleep for 2-7 seconds
        if (done.get() != true) { // Recheck condition for closing, just in case!
          bollieOnField.set(true); // Set Atomic boolean to true
          System.out.println("*********** Bollie collecting balls   ************");
          ballsCollected =
              sharedField
                  .collectAllBallsFromField(); // Collect balls, no golfers allowed to swing while
          // this is happening

          semaphore.drainPermits(); // drain permits so that golfers must wait
          System.out.println(
              "*********** Bollie collected " + ballsCollected.length + " balls ************");

          sleep(1000); // Simulate collecting and adding
          sharedStash.addBallsToStash(ballsCollected); // Add collected balls to stash
          semaphore.release(
              noGolfers); // Release semaphore and all waiting threads, so that golfers waiting can
          // continue to their next swing
          bollieOnField.set(false); // Set Atomic boolean to false, condition no longer blocked
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    sharedStash.golfersGo();
  }
  @Override
  protected void doJob() throws Exception {
    //		log.debug("doJob()");
    temperatureBufferBlockMap.allocate();

    boolean localHalt = shouldHalt;

    while (!localHalt) {
      try {
        jobsToDoSemaphore.acquire();
        jobsToDoSemaphore.drainPermits();
        if (SampleCache.DEBUG_SAMPLE_CACHE_ACTIVITY) {
          log.trace("Attempting to refresh cache.");
        }
        sampleCache.refreshCache();
      } catch (final InterruptedException ie) {
        // Don't care, probably woken up to shutdown
      } catch (final Exception e) {
        if (log.isErrorEnabled()) {
          log.error("Exception caught during cache population run: " + e.toString(), e);
        }
      }
      localHalt = shouldHalt;
    }
  }
 protected void leaveHome() {
   currentBuilding = cityData.buildings.get(home.buildingNumber);
   if (personGui.isInBedroom()) {
     personGui.DoAlmostWall();
     try {
       isMoving.acquire();
     } catch (InterruptedException e) {
       //   Auto-generated catch block
       e.printStackTrace();
     }
     personGui.DoGoToWall();
     try {
       isMoving.acquire();
     } catch (InterruptedException e) {
       //   Auto-generated catch block
       e.printStackTrace();
     }
   }
   if (home instanceof Home) {
     personGui.DoGoToEntrance();
     atEntrance.drainPermits();
     try {
       atEntrance.acquire();
     } catch (InterruptedException e) {
       //   Auto-generated catch block
       e.printStackTrace();
     }
     personGui.DoLeaveBuilding();
     currentBuilding.LeaveBuilding(this);
   }
   if (home instanceof Apartment) {
     Apartment a = (Apartment) home;
     personGui.DoGoToEntrance();
     try {
       isMoving.acquire();
     } catch (InterruptedException e1) {
       //   Auto-generated catch block
       e1.printStackTrace();
     }
     a.rooms.get(roomNumber).LeaveBuilding(this);
     personGui.DoGoToHallway();
     try {
       isMoving.acquire();
     } catch (InterruptedException e) {
       //   Auto-generated catch block
       e.printStackTrace();
     }
     personGui.DoLeaveBuilding();
     a.LeaveBuilding(this);
   }
   bigState = BigState.doingNothing;
 }
  protected void goToMarket() {
    int marketNumber = 0;
    destinationBuilding = cityData.markets.get(0);

    GoToDestination();

    personGui.DoGoToBuilding(19);
    currentBuilding = cityData.buildings.get(19);
    atBuilding.drainPermits();
    try {
      atBuilding.acquire();
    } catch (InterruptedException e) {
      //   Auto-generated catch block
      e.printStackTrace();
    }
    personGui.DoGoIntoBuilding();
    currentBuilding.EnterBuilding(this, desiredRole);
  }
  protected void goToBank() {
    int bankNumber = 0;
    destinationBuilding = cityData.banks.get(bankNumber);
    GoToDestination();

    personGui.DoGoToBuilding(18);
    currentBuilding = cityData.buildings.get(18);
    atBuilding.drainPermits();

    try {
      atBuilding.acquire();
      if (currentBuilding.type == BuildingType.bank) print("made it past at Building acquire");
    } catch (InterruptedException e) {
      //   Auto-generated catch block
      e.printStackTrace();
    }
    personGui.DoGoIntoBuilding();
    print("entering the building and desired role is " + desiredRole);
    currentBuilding.EnterBuilding(this, desiredRole);
  }
 public synchronized String getJSValue(String expression) {
   // Don't try to evaluate js code again if the binding has already been destroyed
   if (!destroyed) {
     // see if this is an expression or a statement block
     // Match ; followed by 0 or even quotes
     Pattern pattern = Pattern.compile(";(?=([^\"]*\"[^\"]*\")*[^\"]*$)");
     Matcher matcher = pattern.matcher(expression);
     if (matcher.find()) {
       String lastStmt = expression.substring(matcher.end(matcher.groupCount() - 1));
       String stmtBlock = expression.substring(0, matcher.end(matcher.groupCount() - 1));
       expression = stmtBlock + " return " + lastStmt;
     } else {
       expression = " return " + expression;
     }
     String code =
         "_TiReturn.setValue((function(){try{"
             + expression
             + "+\"\";}catch(ti_eval_err){return '';}})());";
     Log.d(TAG, "getJSValue:" + code, Log.DEBUG_MODE);
     returnSemaphore.drainPermits();
     synchronized (codeSnippets) {
       codeSnippets.push(code);
     }
     try {
       if (!returnSemaphore.tryAcquire(3500, TimeUnit.MILLISECONDS)) {
         synchronized (codeSnippets) {
           codeSnippets.removeElement(code);
         }
         Log.w(TAG, "Timeout waiting to evaluate JS");
       }
       return returnValue;
     } catch (InterruptedException e) {
       Log.e(TAG, "Interrupted", e);
     }
   }
   return null;
 }
 /**
  * Sets <CODE>playerLocation</CODE>.
  *
  * @param loc the location to be used to set the player location
  */
 private void setPlayerLocation(Location loc) {
   lock.drainPermits(); // Remove all permits
   playerLocation = loc;
   lock.release(); // Allow getPlayerMove to run once
 }
  @Test
  public void testTruncatedLog() throws Exception {
    try {
      DirectUpdateHandler2.commitOnClose = false;
      final Semaphore logReplay = new Semaphore(0);
      final Semaphore logReplayFinish = new Semaphore(0);

      UpdateLog.testing_logReplayHook =
          new Runnable() {
            @Override
            public void run() {
              try {
                assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
              } catch (Exception e) {
                throw new RuntimeException(e);
              }
            }
          };

      UpdateLog.testing_logReplayFinishHook =
          new Runnable() {
            @Override
            public void run() {
              logReplayFinish.release();
            }
          };

      String logDir = h.getCore().getUpdateHandler().getUpdateLog().getLogDir();

      clearIndex();
      assertU(commit());

      assertU(adoc("id", "F1"));
      assertU(adoc("id", "F2"));
      assertU(adoc("id", "F3"));

      h.close();

      String[] files = HdfsUpdateLog.getLogList(fs, new Path(logDir));
      Arrays.sort(files);

      FSDataOutputStream dos = fs.append(new Path(logDir, files[files.length - 1]));

      dos.writeLong(0xffffffffffffffffL);
      dos.writeChars(
          "This should be appended to a good log file, representing a bad partially written record.");
      dos.close();

      logReplay.release(1000);
      logReplayFinish.drainPermits();
      ignoreException(
          "OutOfBoundsException"); // this is what the corrupted log currently produces... subject
      // to change.
      createCore();
      assertTrue(logReplayFinish.tryAcquire(timeout, TimeUnit.SECONDS));
      resetExceptionIgnores();
      assertJQ(req("q", "*:*"), "/response/numFound==3");

      //
      // Now test that the bad log file doesn't mess up retrieving latest versions
      //

      updateJ(
          jsonAdd(sdoc("id", "F4", "_version_", "104")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      updateJ(
          jsonAdd(sdoc("id", "F5", "_version_", "105")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      updateJ(
          jsonAdd(sdoc("id", "F6", "_version_", "106")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));

      // This currently skips the bad log file and also returns the version of the clearIndex (del
      // *:*)
      // assertJQ(req("qt","/get", "getVersions","6"), "/versions==[106,105,104]");
      assertJQ(req("qt", "/get", "getVersions", "3"), "/versions==[106,105,104]");

    } finally {
      DirectUpdateHandler2.commitOnClose = true;
      UpdateLog.testing_logReplayHook = null;
      UpdateLog.testing_logReplayFinishHook = null;
    }
  }
Exemple #10
0
  @Test
  public void testBuffering() throws Exception {

    DirectUpdateHandler2.commitOnClose = false;
    final Semaphore logReplay = new Semaphore(0);
    final Semaphore logReplayFinish = new Semaphore(0);

    UpdateLog.testing_logReplayHook =
        new Runnable() {
          @Override
          public void run() {
            try {
              assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
            } catch (Exception e) {
              throw new RuntimeException(e);
            }
          }
        };

    UpdateLog.testing_logReplayFinishHook =
        new Runnable() {
          @Override
          public void run() {
            logReplayFinish.release();
          }
        };

    SolrQueryRequest req = req();
    UpdateHandler uhandler = req.getCore().getUpdateHandler();
    UpdateLog ulog = uhandler.getUpdateLog();

    try {
      clearIndex();
      assertU(commit());

      assertEquals(UpdateLog.State.ACTIVE, ulog.getState());
      ulog.bufferUpdates();
      assertEquals(UpdateLog.State.BUFFERING, ulog.getState());
      Future<UpdateLog.RecoveryInfo> rinfoFuture = ulog.applyBufferedUpdates();
      assertTrue(rinfoFuture == null);
      assertEquals(UpdateLog.State.ACTIVE, ulog.getState());

      ulog.bufferUpdates();
      assertEquals(UpdateLog.State.BUFFERING, ulog.getState());

      // simulate updates from a leader
      updateJ(
          jsonAdd(sdoc("id", "B1", "_version_", "1010")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      updateJ(
          jsonAdd(sdoc("id", "B11", "_version_", "1015")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      updateJ(
          jsonDelQ("id:B1 id:B11 id:B2 id:B3"),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-1017"));
      updateJ(
          jsonAdd(sdoc("id", "B2", "_version_", "1020")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      updateJ(
          jsonAdd(sdoc("id", "B3", "_version_", "1030")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      deleteAndGetVersion("B1", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-2010"));

      assertJQ(
          req("qt", "/get", "getVersions", "6"),
          "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");

      assertU(commit());

      assertJQ(
          req("qt", "/get", "getVersions", "6"),
          "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");

      // updates should be buffered, so we should not see any results yet.
      assertJQ(req("q", "*:*"), "/response/numFound==0");

      // real-time get should also not show anything (this could change in the future,
      // but it's currently used for validating version numbers too, so it would
      // be bad for updates to be visible if we're just buffering.
      assertJQ(req("qt", "/get", "id", "B3"), "=={'doc':null}");

      rinfoFuture = ulog.applyBufferedUpdates();
      assertTrue(rinfoFuture != null);

      assertEquals(UpdateLog.State.APPLYING_BUFFERED, ulog.getState());

      logReplay.release(1000);

      UpdateLog.RecoveryInfo rinfo = rinfoFuture.get();
      assertEquals(UpdateLog.State.ACTIVE, ulog.getState());

      assertJQ(
          req("qt", "/get", "getVersions", "6"),
          "=={'versions':[-2010,1030,1020,-1017,1015,1010]}");

      assertJQ(req("q", "*:*"), "/response/numFound==2");

      // move back to recovering
      ulog.bufferUpdates();
      assertEquals(UpdateLog.State.BUFFERING, ulog.getState());

      Long ver = getVer(req("qt", "/get", "id", "B3"));
      assertEquals(1030L, ver.longValue());

      // add a reordered doc that shouldn't overwrite one in the index
      updateJ(
          jsonAdd(sdoc("id", "B3", "_version_", "3")), params(DISTRIB_UPDATE_PARAM, FROM_LEADER));

      // reorder two buffered updates
      updateJ(
          jsonAdd(sdoc("id", "B4", "_version_", "1040")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      deleteAndGetVersion(
          "B4",
          params(
              DISTRIB_UPDATE_PARAM,
              FROM_LEADER,
              "_version_",
              "-940")); // this update should not take affect
      updateJ(
          jsonAdd(sdoc("id", "B6", "_version_", "1060")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      updateJ(
          jsonAdd(sdoc("id", "B5", "_version_", "1050")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));
      updateJ(
          jsonAdd(sdoc("id", "B8", "_version_", "1080")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));

      // test that delete by query is at least buffered along with everything else so it will delete
      // the
      // currently buffered id:8 (even if it doesn't currently support versioning)
      updateJ(
          "{\"delete\": { \"query\":\"id:B2 OR id:B8\" }}",
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-3000"));

      assertJQ(
          req("qt", "/get", "getVersions", "13"),
          "=={'versions':[-3000,1080,1050,1060,-940,1040,3,-2010,1030,1020,-1017,1015,1010]}" // the
          // "3"
          // appears because versions aren't checked while buffering
          );

      logReplay.drainPermits();
      rinfoFuture = ulog.applyBufferedUpdates();
      assertTrue(rinfoFuture != null);
      assertEquals(UpdateLog.State.APPLYING_BUFFERED, ulog.getState());

      // apply a single update
      logReplay.release(1);

      // now add another update
      updateJ(
          jsonAdd(sdoc("id", "B7", "_version_", "1070")),
          params(DISTRIB_UPDATE_PARAM, FROM_LEADER));

      // a reordered update that should be dropped
      deleteAndGetVersion("B5", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-950"));

      deleteAndGetVersion("B6", params(DISTRIB_UPDATE_PARAM, FROM_LEADER, "_version_", "-2060"));

      logReplay.release(1000);
      UpdateLog.RecoveryInfo recInfo = rinfoFuture.get();

      assertJQ(
          req("q", "*:*", "sort", "id asc", "fl", "id,_version_"),
          "/response/docs==["
              + "{'id':'B3','_version_':1030}"
              + ",{'id':'B4','_version_':1040}"
              + ",{'id':'B5','_version_':1050}"
              + ",{'id':'B7','_version_':1070}"
              + "]");

      assertEquals(1, recInfo.deleteByQuery);

      assertEquals(
          UpdateLog.State.ACTIVE, ulog.getState()); // leave each test method in a good state
    } finally {
      DirectUpdateHandler2.commitOnClose = true;
      UpdateLog.testing_logReplayHook = null;
      UpdateLog.testing_logReplayFinishHook = null;

      req().close();
    }
  }
Exemple #11
0
  // in rare circumstances, two logs can be left uncapped (lacking a commit at the end signifying
  // that all the content in the log was committed)
  @Test
  public void testRecoveryMultipleLogs() throws Exception {
    try {
      DirectUpdateHandler2.commitOnClose = false;
      final Semaphore logReplay = new Semaphore(0);
      final Semaphore logReplayFinish = new Semaphore(0);

      UpdateLog.testing_logReplayHook =
          new Runnable() {
            @Override
            public void run() {
              try {
                assertTrue(logReplay.tryAcquire(timeout, TimeUnit.SECONDS));
              } catch (Exception e) {
                throw new RuntimeException(e);
              }
            }
          };

      UpdateLog.testing_logReplayFinishHook =
          new Runnable() {
            @Override
            public void run() {
              logReplayFinish.release();
            }
          };

      String logDir = h.getCore().getUpdateHandler().getUpdateLog().getLogDir();

      clearIndex();
      assertU(commit());

      assertU(adoc("id", "AAAAAA"));
      assertU(adoc("id", "BBBBBB"));
      assertU(adoc("id", "CCCCCC"));

      h.close();
      String[] files = HdfsUpdateLog.getLogList(fs, new Path(logDir));
      Arrays.sort(files);
      String fname = files[files.length - 1];

      FSDataOutputStream dos = fs.append(new Path(logDir, files[files.length - 1]));
      dos.writeLong(0xffffffffffffffffL);
      dos.writeChars(
          "This should be appended to a good log file, representing a bad partially written record.");
      dos.close();

      FSDataInputStream dis = fs.open(new Path(logDir, files[files.length - 1]));
      byte[] content = new byte[(int) dis.available()];

      dis.readFully(content);

      dis.close();

      // Now make a newer log file with just the IDs changed.  NOTE: this may not work if log format
      // changes too much!
      findReplace(
          "AAAAAA".getBytes(StandardCharsets.UTF_8),
          "aaaaaa".getBytes(StandardCharsets.UTF_8),
          content);
      findReplace(
          "BBBBBB".getBytes(StandardCharsets.UTF_8),
          "bbbbbb".getBytes(StandardCharsets.UTF_8),
          content);
      findReplace(
          "CCCCCC".getBytes(StandardCharsets.UTF_8),
          "cccccc".getBytes(StandardCharsets.UTF_8),
          content);

      // WARNING... assumes format of .00000n where n is less than 9
      long logNumber = Long.parseLong(fname.substring(fname.lastIndexOf(".") + 1));
      String fname2 =
          String.format(
              Locale.ROOT, UpdateLog.LOG_FILENAME_PATTERN, UpdateLog.TLOG_NAME, logNumber + 1);

      dos = fs.create(new Path(logDir, fname2), (short) 1);
      dos.write(content);
      dos.close();

      logReplay.release(1000);
      logReplayFinish.drainPermits();
      ignoreException(
          "OutOfBoundsException"); // this is what the corrupted log currently produces... subject
      // to change.
      createCore();
      assertTrue(logReplayFinish.tryAcquire(timeout, TimeUnit.SECONDS));
      resetExceptionIgnores();
      assertJQ(req("q", "*:*"), "/response/numFound==6");

    } finally {
      DirectUpdateHandler2.commitOnClose = true;
      UpdateLog.testing_logReplayHook = null;
      UpdateLog.testing_logReplayFinishHook = null;
    }
  }
Exemple #12
0
 public void reset() {
   semaphore.drainPermits();
   msg = null;
 }
    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public V call() {
      T value = source.getAttribute(sensor);

      // return immediately if either the ready predicate or the abort conditions hold
      if (ready(value)) return postProcess(value);

      final List<Exception> abortionExceptions = Lists.newCopyOnWriteArrayList();
      long start = System.currentTimeMillis();

      for (AttributeAndSensorCondition abortCondition : abortSensorConditions) {
        Object abortValue = abortCondition.source.getAttribute(abortCondition.sensor);
        if (abortCondition.predicate.apply(abortValue)) {
          abortionExceptions.add(
              new Exception(
                  "Abort due to " + abortCondition.source + " -> " + abortCondition.sensor));
        }
      }
      if (abortionExceptions.size() > 0) {
        throw new CompoundRuntimeException(
            "Aborted waiting for ready from " + source + " " + sensor, abortionExceptions);
      }

      TaskInternal<?> current = (TaskInternal<?>) Tasks.current();
      if (current == null)
        throw new IllegalStateException("Should only be invoked in a running task");
      Entity entity = BrooklynTaskTags.getTargetOrContextEntity(current);
      if (entity == null)
        throw new IllegalStateException(
            "Should only be invoked in a running task with an entity tag; "
                + current
                + " has no entity tag ("
                + current.getStatusDetail(false)
                + ")");

      final LinkedList<T> publishedValues = new LinkedList<T>();
      final Semaphore semaphore = new Semaphore(0); // could use Exchanger
      SubscriptionHandle subscription = null;
      List<SubscriptionHandle> abortSubscriptions = Lists.newArrayList();

      try {
        subscription =
            entity
                .subscriptions()
                .subscribe(
                    source,
                    sensor,
                    new SensorEventListener<T>() {
                      @Override
                      public void onEvent(SensorEvent<T> event) {
                        synchronized (publishedValues) {
                          publishedValues.add(event.getValue());
                        }
                        semaphore.release();
                      }
                    });
        for (final AttributeAndSensorCondition abortCondition : abortSensorConditions) {
          abortSubscriptions.add(
              entity
                  .subscriptions()
                  .subscribe(
                      abortCondition.source,
                      abortCondition.sensor,
                      new SensorEventListener<Object>() {
                        @Override
                        public void onEvent(SensorEvent<Object> event) {
                          if (abortCondition.predicate.apply(event.getValue())) {
                            abortionExceptions.add(
                                new Exception(
                                    "Abort due to "
                                        + abortCondition.source
                                        + " -> "
                                        + abortCondition.sensor));
                            semaphore.release();
                          }
                        }
                      }));
          Object abortValue = abortCondition.source.getAttribute(abortCondition.sensor);
          if (abortCondition.predicate.apply(abortValue)) {
            abortionExceptions.add(
                new Exception(
                    "Abort due to " + abortCondition.source + " -> " + abortCondition.sensor));
          }
        }
        if (abortionExceptions.size() > 0) {
          throw new CompoundRuntimeException(
              "Aborted waiting for ready from " + source + " " + sensor, abortionExceptions);
        }

        CountdownTimer timer = timeout != null ? timeout.countdownTimer() : null;
        Duration maxPeriod = ValueResolver.PRETTY_QUICK_WAIT;
        Duration nextPeriod = ValueResolver.REAL_QUICK_PERIOD;
        while (true) {
          // check the source on initial run (could be done outside the loop)
          // and also (optionally) on each iteration in case it is more recent
          value = source.getAttribute(sensor);
          if (ready(value)) break;

          if (timer != null) {
            if (timer.getDurationRemaining().isShorterThan(nextPeriod)) {
              nextPeriod = timer.getDurationRemaining();
            }
            if (timer.isExpired()) {
              if (onTimeout.isPresent()) return onTimeout.get();
              throw new RuntimeTimeoutException("Unsatisfied after " + Duration.sinceUtc(start));
            }
          }

          String prevBlockingDetails = current.setBlockingDetails(blockingDetails);
          try {
            if (semaphore.tryAcquire(nextPeriod.toMilliseconds(), TimeUnit.MILLISECONDS)) {
              // immediately release so we are available for the next check
              semaphore.release();
              // if other permits have been made available (e.g. multiple notifications) drain them
              // all as no point running multiple times
              semaphore.drainPermits();
            }
          } finally {
            current.setBlockingDetails(prevBlockingDetails);
          }

          // check any subscribed values which have come in first
          while (true) {
            synchronized (publishedValues) {
              if (publishedValues.isEmpty()) break;
              value = publishedValues.pop();
            }
            if (ready(value)) break;
          }

          // if unmanaged then ignore the other abort conditions
          if (!ignoreUnmanaged && Entities.isNoLongerManaged(entity)) {
            if (onUnmanaged.isPresent()) return onUnmanaged.get();
            throw new NotManagedException(entity);
          }

          if (abortionExceptions.size() > 0) {
            throw new CompoundRuntimeException(
                "Aborted waiting for ready from " + source + " " + sensor, abortionExceptions);
          }

          nextPeriod = nextPeriod.times(2).upperBound(maxPeriod);
        }
        if (LOG.isDebugEnabled()) LOG.debug("Attribute-ready for {} in entity {}", sensor, source);
        return postProcess(value);
      } catch (InterruptedException e) {
        throw Exceptions.propagate(e);
      } finally {
        if (subscription != null) {
          entity.subscriptions().unsubscribe(subscription);
        }
        for (SubscriptionHandle handle : abortSubscriptions) {
          entity.subscriptions().unsubscribe(handle);
        }
      }
    }
  @Override
  public void run() {

    final Semaphore sem = new Semaphore(0);
    final List<String> logs = new ArrayList<String>();
    final Map<String, List<String>> logsToSync = new HashMap<String, List<String>>();
    final List<Session> sessions = new ArrayList<Session>();

    GenericWebsocketClient gwc =
        new GenericWebsocketClient(
            new WebsocketClient() {
              @Override
              public void onOpen(final Session session, EndpointConfig config) {
                try {
                  sessions.add(session);
                  String sid = session.getId();
                  List<String> sl = Collections.synchronizedList(new ArrayList<String>(logs));
                  logsToSync.put(sid, sl);

                  for (String id : sl) {
                    AttLog log = attLogsManager.findById(id);
                    String json = attLogSerializer.toJson(log);
                    String cmdJson = "attLog;" + json;

                    logger.info(cmdJson);
                    session.getBasicRemote().sendText(cmdJson);
                  }

                } catch (Exception e) {
                  logger.log(Level.SEVERE, e.getMessage(), e);
                  sem.release();
                }
              }

              @Override
              public void onClose(Session s, CloseReason reason) {
                logger.info("onClose");
                sem.release();
              }

              @Override
              public void onMessage(String m, Session session) {
                logger.info("onMessage " + m);

                String sid = session.getId();
                List<String> sl = logsToSync.get(sid);

                String cmd = "OK;delete;";
                if (m.startsWith(cmd)) {

                  String id = m.substring(cmd.length());
                  try {
                    attLogsManager.remove(id);
                    if (sl != null) {
                      sl.remove(id);
                    }

                    if (sl == null || sl.size() <= 0) {
                      sem.release();
                    }

                  } catch (AttLogException e) {
                    logger.log(Level.SEVERE, e.getMessage(), e);
                    sem.release();
                  }
                }
              }
            });

    final URI uri =
        URI.create("ws://" + serverData.getIp() + ":" + serverData.getPort() + serverData.getUrl());

    while (true) {

      // busco a ver si existen logs a ser sincronizados.
      logs.clear();
      try {
        List<String> ls = attLogsManager.findAll();

        if (ls != null && ls.size() > 0) {

          logs.addAll(ls);
          sem.drainPermits();

          logger.info("connecting to : " + uri.toString());
          ContainerProvider.getWebSocketContainer().connectToServer(gwc, uri);

          try {
            sem.acquire();

          } catch (InterruptedException e1) {
            e1.printStackTrace();
          }
        }

      } catch (DeploymentException | AttLogException e) {
        logger.log(Level.SEVERE, e.getMessage(), e);

      } catch (IOException e) {
        logger.log(Level.SEVERE, e.getMessage(), e);

      } catch (Exception e) {
        logger.log(Level.SEVERE, e.getMessage(), e);
      }

      // limpio todas las sesiones que hayan quedado habiertas.
      for (Session s : sessions) {
        try {
          if (s.isOpen()) {
            s.close();
          }
        } catch (IOException e) {
        }
      }
      sessions.clear();
      logsToSync.clear();
      logs.clear();

      try {
        // espero a que alguien marque o hasta que se cumpla el sleep.
        MutualExclusion.using[MutualExclusion.NEED_ATTLOGS_SYNC].tryAcquire(
            sleep, TimeUnit.MILLISECONDS);

      } catch (InterruptedException e) {

      }
    }
  }
  public void GoToDestination() {
    currGrid = cityData.cityGrid[personGui.getX() / 20][personGui.getY() / 20];
    if (walk == true) {
      personGui.DoGoToBuilding(destinationBuilding.buildingNumber);

      // PersonGui.DoWalk(if you ever hit an RGrid, acquire it first, and then walk through, and
      // don't walk through bgrids)
      walking = true;
      while (walking) {

        if (crossingRoad) {
          try {
            currRGrid.occupied.acquire();
            // System.out.println("1");
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
          try {
            nextRGrid.occupied.acquire();
            // System.out.println("2");
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
          personGui.crossRoad();
          try {
            gridding.acquire();
          } catch (Exception e) {
          }
          currRGrid.occupied.release();
          // System.out.println("1");
          nextRGrid.occupied.release();
          // System.out.println("0");
          // ACQUIRE CURRENT AND NEXT
        } else {
          //				// go from grid to grid
          //				currGrid = nextGrid
          ////				if undo
          ////				if(curr instanceof RGrid) {
          ////					person.acquire those next two semaphores in that direction
          ////					personGui.crossRoad(direction);
          ////					move to next
          ////					release roads
          ////				}
          //				else {
          //				//personGui.MoveToNextGrid;
          //				}
          // print("hello");

          personGui.MoveToNextGrid(currGrid);
          try {
            gridding.acquire();
          } catch (Exception e) {
          }
        }
      }
    }
    if (car == true) {
      currentBuilding.closest.acquireGrid();
      currRGrid = currentBuilding.closest;
      personGui.DoWalkToRGrid(currentBuilding.buildingNumber);
      // personGui.//acquire the semaphore of the
      // road(currentBuilding.closest.index1(),currentBuilding.closest.index2())
      // then he moves like a bus until he gets to his destinatoin's rgrid, gets off road
      // then he releases last road semaphore
      isMoving.drainPermits();
      try {
        isMoving.acquire();
      } catch (Exception e) {
      }

      System.err.println("hello");

      personGui.getInOrOutCar();
      personGui.DriveToDestination(destinationBuilding);
      // personGui.DriveToClosestRGrid(destinationBuilding); **** have similar mechanisms to
      // busgridbehavior
      // if person's rgrid is destination.closestRgrid, then, walk to building

      driving = true;
      while (driving) {

        if (gridToAcquire != null) {
          MoveToGrid();
          continue;
        }

        // puts this "mini-scheduler" to sleep
        try {
          isMoving.acquire();
        } catch (Exception e) {
        }
      }
      // remember to release current and previous grids
      currRGrid.releaseGrid();
      prevRGrid.releaseGrid();
      gridToAcquire.releaseGrid();

      // WALKT TO THE BUILDING NOW

      currRGrid = currentBuilding.closest;

      /*currRGrid = currentBuilding.closest;
      >>>>>>> 0a17ff0b1dfacf5cdfd33fa5a6faac8714cda482
      			//personGui.;
      			driving = true;
      			while(driving) {
      				try
      				{
      					//.acquire();
      				}
      				catch(Exception e){}

      				personGui.getInOrOutCar();
      				//personGui.DriveToClosestRGrid(destinationBuilding); **** have similar mechanisms to busgridbehavior
      				//if person's rgrid is destination.closestRgrid, then, walk to building

      				try
      				{
      					isMoving.acquire();
      				}
      				catch(Exception e){}
      				driving = false;
      			}*/
      // personGui
      // have similar mechanisms to busgridbehavior
      // if person's rgrid is destination.closestRgrid, then, walk to building
      // YOU WILL TURN INTO A ROBOT
    }
    if (bus == true) {
      destinationBusStop = currentBuilding.busStop;
      personGui.DoGoToBusStop(destinationBusStop);
      try {
        isMoving.acquire();
      } catch (Exception e) {
      }
      currentBusStop = destinationBusStop;
      destinationBusStop = destinationBuilding.busStop;

      currentBusStop.msgWaitingAtStop(this, destinationBusStop);
      try {
        isMoving.acquire();
      } catch (Exception e) {
      }

      if (currentBus == null) {
        try {
          isMoving.acquire();
        } catch (Exception e) {
        }
      }

      personGui.DoGoToBus(currentBus);
      try {
        isMoving.acquire();
      } catch (Exception e) {
      }

      cityData.guis.remove(personGui);
      currentBus.msgOnBus();
      try {
        isMoving.acquire();
      } catch (Exception e) {
      }

      cityData.guis.add(personGui);
      personGui.setXPos(currentBus.getX());
      personGui.setYPos(currentBus.getY());
      currentBus.msgOnBus();
      personGui.DoGoToBusStop(destinationBusStop); // THIS SHOULD ACQUIRE ROAD SEMAPHORE
      // if it needs to
      try {
        isMoving.acquire();
      } catch (Exception e) {
      }
    }

    currentBuilding = destinationBuilding;
  }