Exemplo n.º 1
0
  /**
   * @param from From version.
   * @param to To version.
   */
  public void mapVersion(GridCacheVersion from, GridCacheVersion to) {
    assert from != null;
    assert to != null;

    GridCacheVersion old = near2dht.put(from, to);

    assert old == null || old == to || old.equals(to);

    if (log.isDebugEnabled()) log.debug("Added version mapping [from=" + from + ", to=" + to + ']');
  }
Exemplo n.º 2
0
  /**
   * Marks near-local candidate as ready and makes locks reassignment. Following reorderings are
   * performed when candidate is marked ready:
   *
   * <ul>
   *   <li/>All candidates preceding ready one are moved right after it.
   *   <li/>Near local candidate is assigned a mapped dht version. All remote non-pending candidates
   *       with version less then mapped dht version are marked as owned.
   * </ul>
   *
   * @param ver Version to mark as ready.
   * @param mappedVer Mapped dht version.
   * @param committedVers Committed versions.
   * @param rolledBackVers Rolled back versions.
   * @param pending Pending dht versions that are not owned and which version is less then mapped.
   * @return Lock owner after reassignment.
   */
  @Nullable
  public CacheLockCandidates readyNearLocal(
      GridCacheVersion ver,
      GridCacheVersion mappedVer,
      Collection<GridCacheVersion> committedVers,
      Collection<GridCacheVersion> rolledBackVers,
      Collection<GridCacheVersion> pending) {
    GridCacheMvccCandidate cand = candidate(locs, ver);

    if (cand != null) {
      assert cand.nearLocal() : "Near local candidate is not marked as near local: " + cand;

      cand.setReady();

      boolean setMapped = cand.otherVersion(mappedVer);

      assert setMapped
          : "Failed to set mapped dht version for near local candidate [mappedVer="
              + mappedVer
              + ", cand="
              + cand
              + ']';

      // For near locals we move all not owned candidates after this one.
      List<GridCacheMvccCandidate> mvAfter = null;

      for (ListIterator<GridCacheMvccCandidate> it = locs.listIterator(); it.hasNext(); ) {
        GridCacheMvccCandidate c = it.next();

        assert c.nearLocal() : "Near local candidate is not marked as near local: " + c;

        if (c == cand) {
          if (mvAfter != null) for (GridCacheMvccCandidate mv : mvAfter) it.add(mv);

          break;
        } else {
          if (c.owner()) continue;

          assert !c.ready() || (c.read() && cand.read())
              : "Cannot have more then one ready near-local candidate [c="
                  + c
                  + ", cand="
                  + cand
                  + ", mvcc="
                  + this
                  + ']';

          it.remove();

          if (mvAfter == null) mvAfter = new LinkedList<>();

          mvAfter.add(c);
        }
      }

      // Mark all remote candidates with less version as owner unless it is pending.
      if (rmts != null) {
        for (GridCacheMvccCandidate rmt : rmts) {
          GridCacheVersion rmtVer = rmt.version();

          if (rmtVer.isLess(mappedVer)) {
            if (!pending.contains(rmtVer) && !mappedVer.equals(rmt.ownerVersion())) rmt.setOwner();
          } else {
            // Remote version is greater, so need to check if it was committed or rolled back.
            if (committedVers.contains(rmtVer) || rolledBackVers.contains(rmtVer)) rmt.setOwner();
          }
        }
      }

      reassign();
    }

    return allOwners();
  }