@Override
  public void cmdExecute(Message msg, ServerConnection servConn, long start) throws IOException {
    // requiresResponse = true; NOT NEEDED... ALWAYS SEND ERROR RESPONSE

    logger.fatal(
        LocalizedMessage.create(
            LocalizedStrings.Default_0_UNKNOWN_MESSAGE_TYPE_1_WITH_TX_2_FROM_3,
            new Object[] {
              servConn.getName(),
              MessageType.getString(msg.getMessageType()),
              Integer.valueOf(msg.getTransactionId()),
              servConn.getSocketString()
            }));
    writeErrorResponse(msg, MessageType.UNKNOWN_MESSAGE_TYPE_ERROR, servConn);
    // responded = true; NOT NEEDED... ALWAYS SEND ERROR RESPONSE
  }
Esempio n. 2
0
  @Override
  public void cmdExecute(Message msg, ServerConnection servConn, long start)
      throws IOException, ClassNotFoundException {
    servConn.setAsTrue(REQUIRES_RESPONSE);
    if (logger.fineEnabled()) {
      logger.fine(
          servConn.getName()
              + ": Received get pdx id for enum request ("
              + msg.getNumberOfParts()
              + " parts) from "
              + servConn.getSocketString());
    }
    int noOfParts = msg.getNumberOfParts();

    EnumInfo enumInfo = (EnumInfo) msg.getPart(0).getObject();
    int enumId = msg.getPart(1).getInt();

    try {
      GemFireCacheImpl cache = (GemFireCacheImpl) servConn.getCache();
      TypeRegistry registry = cache.getPdxRegistry();
      registry.addRemoteEnum(enumId, enumInfo);
    } catch (Exception e) {
      writeException(msg, e, false, servConn);
      servConn.setAsTrue(RESPONDED);
      return;
    }

    writeReply(msg, servConn);
    servConn.setAsTrue(RESPONDED);
  }
Esempio n. 3
0
  @Override
  public void cmdExecute(Message msg, ServerConnection servConn, long start)
      throws IOException, InterruptedException {
    Part regionNamePart = null, keyPart = null, valuePart = null, callbackArgPart = null;
    String regionName = null;
    Object callbackArg = null, key = null;
    Part eventPart = null;
    String errMessage = "";
    CachedRegionHelper crHelper = servConn.getCachedRegionHelper();
    CacheServerStats stats = servConn.getCacheServerStats();
    if (crHelper.emulateSlowServer() > 0) {
      // this.logger.fine("SlowServer", new Exception());
      boolean interrupted = Thread.interrupted();
      try {
        Thread.sleep(crHelper.emulateSlowServer());
      } catch (InterruptedException ugh) {
        interrupted = true;
      } finally {
        if (interrupted) {
          Thread.currentThread().interrupt();
        }
      }
      ;
    }

    // requiresResponse = true;
    servConn.setAsTrue(REQUIRES_RESPONSE);
    {
      long oldStart = start;
      start = DistributionStats.getStatTime();
      stats.incReadPutRequestTime(start - oldStart);
    }
    // Retrieve the data from the message parts
    regionNamePart = msg.getPart(0);
    keyPart = msg.getPart(1);
    valuePart = msg.getPart(2);
    eventPart = msg.getPart(3);
    //    callbackArgPart = null; (redundant assignment)
    if (msg.getNumberOfParts() > 4) {
      callbackArgPart = msg.getPart(4);
      try {
        callbackArg = callbackArgPart.getObject();
      } catch (Exception e) {
        writeException(msg, e, false, servConn);
        servConn.setAsTrue(RESPONDED);
        return;
      }
    }
    regionName = regionNamePart.getString();

    try {
      key = keyPart.getStringOrObject();
    } catch (Exception e) {
      writeException(msg, e, false, servConn);
      servConn.setAsTrue(RESPONDED);
      return;
    }

    if (logger.finestEnabled()) {
      logger.finest(
          servConn.getName()
              + ": Received put request ("
              + msg.getPayloadLength()
              + " bytes) from "
              + servConn.getSocketString()
              + " for region "
              + regionName
              + " key "
              + key
              + " value "
              + valuePart);
    }

    // Process the put request
    if (key == null || regionName == null) {
      if (key == null) {
        if (logger.warningEnabled()) {
          logger.warning(
              LocalizedStrings.Put_0_THE_INPUT_KEY_FOR_THE_PUT_REQUEST_IS_NULL, servConn.getName());
        }
        errMessage =
            LocalizedStrings.Put_THE_INPUT_KEY_FOR_THE_PUT_REQUEST_IS_NULL.toLocalizedString();
      }
      if (regionName == null) {
        if (logger.warningEnabled()) {
          logger.warning(
              LocalizedStrings.Put_0_THE_INPUT_REGION_NAME_FOR_THE_PUT_REQUEST_IS_NULL,
              servConn.getName());
        }
        errMessage =
            LocalizedStrings.Put_THE_INPUT_REGION_NAME_FOR_THE_PUT_REQUEST_IS_NULL
                .toLocalizedString();
      }
      writeErrorResponse(msg, MessageType.PUT_DATA_ERROR, errMessage.toString(), servConn);
      servConn.setAsTrue(RESPONDED);
    } else {
      LocalRegion region = (LocalRegion) crHelper.getRegion(regionName);
      if (region == null) {
        String reason =
            LocalizedStrings.Put_REGION_WAS_NOT_FOUND_DURING_PUT_REQUEST.toLocalizedString();
        writeRegionDestroyedEx(msg, regionName, reason, servConn);
        servConn.setAsTrue(RESPONDED);
      } else if (valuePart.isNull() && region.containsKey(key)) {
        // Invalid to 'put' a null value in an existing key
        if (logger.infoEnabled()) {
          logger.info(
              LocalizedStrings.Put_0_ATTEMPTED_TO_PUT_A_NULL_VALUE_FOR_EXISTING_KEY_1,
              new Object[] {servConn.getName(), key});
        }
        errMessage =
            LocalizedStrings.Put_ATTEMPTED_TO_PUT_A_NULL_VALUE_FOR_EXISTING_KEY_0
                .toLocalizedString();
        writeErrorResponse(msg, MessageType.PUT_DATA_ERROR, errMessage, servConn);
        servConn.setAsTrue(RESPONDED);
      } else {
        // try {
        // this.eventId = (EventID)eventPart.getObject();
        ByteBuffer eventIdPartsBuffer = ByteBuffer.wrap(eventPart.getSerializedForm());
        long threadId = EventID.readEventIdPartsFromOptmizedByteArray(eventIdPartsBuffer);
        long sequenceId = EventID.readEventIdPartsFromOptmizedByteArray(eventIdPartsBuffer);
        EventID eventId = new EventID(servConn.getEventMemberIDByteArray(), threadId, sequenceId);
        // } catch (Exception e) {
        // writeException(msg, e, false);
        // responded = true;
        // continue;
        // }
        try {
          byte[] value = valuePart.getSerializedForm();
          boolean isObject = valuePart.isObject();
          AuthorizeRequest authzRequest = servConn.getAuthzRequest();
          if (authzRequest != null) {
            // TODO SW: This is to handle DynamicRegionFactory create
            // calls. Rework this when the semantics of DynamicRegionFactory are
            // cleaned up.
            if (DynamicRegionFactory.regionIsDynamicRegionList(regionName)) {
              authzRequest.createRegionAuthorize((String) key);
            }
            // Allow PUT operations on meta regions (bug #38961)
            else if (!region.isUsedForMetaRegion()) {
              PutOperationContext putContext =
                  authzRequest.putAuthorize(regionName, key, value, isObject, callbackArg);
              value = putContext.getSerializedValue();
              isObject = putContext.isObject();
              callbackArg = putContext.getCallbackArg();
            }
          }
          // If the value is 1 byte and the byte represents null,
          // attempt to create the entry. This test needs to be
          // moved to DataSerializer or DataSerializer.NULL needs
          // to be publicly accessible.
          boolean result = false;
          if (value == null) {
            // Create the null entry. Since the value is null, the value of the
            // isObject
            // the true after null doesn't matter and is not used.
            result =
                region.basicBridgeCreate(
                    key,
                    null,
                    true,
                    callbackArg,
                    servConn.getProxyID(),
                    true,
                    new EntryEventImpl(eventId),
                    false);
          } else {
            // Put the entry
            result =
                region.basicBridgePut(
                    key,
                    value,
                    null,
                    isObject,
                    callbackArg,
                    servConn.getProxyID(),
                    true,
                    servConn.isGemFireXDSystem(),
                    new EntryEventImpl(eventId));
          }
          if (result) {
            servConn.setModificationInfo(true, regionName, key);
          } else {
            StringId message =
                LocalizedStrings.PUT_0_FAILED_TO_PUT_ENTRY_FOR_REGION_1_KEY_2_VALUE_3;
            Object[] messageArgs = new Object[] {servConn.getName(), regionName, key, valuePart};

            if (logger.infoEnabled()) {
              logger.info(message, messageArgs);
            }
            throw new Exception(message.toLocalizedString(messageArgs));
          }
        } catch (RegionDestroyedException rde) {
          writeException(msg, rde, false, servConn);
          servConn.setAsTrue(RESPONDED);
          return;
        } catch (ResourceException re) {
          writeException(msg, re, false, servConn);
          servConn.setAsTrue(RESPONDED);
          return;
        } catch (Exception ce) {
          // If an interrupted exception is thrown , rethrow it
          checkForInterrupt(servConn, ce);

          // If an exception occurs during the put, preserve the connection
          writeException(msg, ce, false, servConn);
          servConn.setAsTrue(RESPONDED);
          if (ce instanceof GemFireSecurityException) {
            // Fine logging for security exceptions since these are already
            // logged by the security logger
            if (logger.fineEnabled()) {
              logger.fine(servConn.getName() + ": Unexpected Security exception", ce);
            }
          } else if (logger.warningEnabled()) {
            logger.warning(LocalizedStrings.PUT_0_UNEXPECTED_EXCEPTION, servConn.getName(), ce);
          }
          return;
        } finally {
          long oldStart = start;
          start = DistributionStats.getStatTime();
          stats.incProcessPutTime(start - oldStart);
        }

        // Increment statistics and write the reply
        writeReply(msg, servConn);

        servConn.setAsTrue(RESPONDED);
        if (logger.fineEnabled()) {
          logger.fine(
              servConn.getName()
                  + ": Sent put response back to "
                  + servConn.getSocketString()
                  + " for region "
                  + regionName
                  + " key "
                  + key
                  + " value "
                  + valuePart);
        }
        stats.incWritePutResponseTime(DistributionStats.getStatTime() - start);
      }
    }
  }
Esempio n. 4
0
  @Override
  public void cmdExecute(Message msg, ServerConnection servConn, long start)
      throws IOException, InterruptedException {
    Part regionNamePart = null, keyPart = null, callbackArgPart = null;
    String regionName = null;
    Object callbackArg = null, key = null;
    Part eventPart = null;
    CachedRegionHelper crHelper = servConn.getCachedRegionHelper();
    CacheServerStats stats = servConn.getCacheServerStats();
    servConn.setAsTrue(REQUIRES_RESPONSE);

    {
      long oldStart = start;
      start = DistributionStats.getStatTime();
      stats.incReadInvalidateRequestTime(start - oldStart);
    }
    // Retrieve the data from the message parts
    regionNamePart = msg.getPart(0);
    keyPart = msg.getPart(1);
    eventPart = msg.getPart(2);
    //    callbackArgPart = null; (redundant assignment)
    if (msg.getNumberOfParts() > 3) {
      callbackArgPart = msg.getPart(3);
      try {
        callbackArg = callbackArgPart.getObject();
      } catch (Exception e) {
        writeException(msg, e, false, servConn);
        servConn.setAsTrue(RESPONDED);
        return;
      }
    }
    regionName = regionNamePart.getString();
    try {
      key = keyPart.getStringOrObject();
    } catch (Exception e) {
      writeException(msg, e, false, servConn);
      servConn.setAsTrue(RESPONDED);
      return;
    }
    if (logger.fineEnabled()) {
      logger.fine(
          servConn.getName()
              + ": Received invalidate request ("
              + msg.getPayloadLength()
              + " bytes) from "
              + servConn.getSocketString()
              + " for region "
              + regionName
              + " key "
              + key);
    }

    // Process the invalidate request
    if (key == null || regionName == null) {
      StringBuilder errMessage = new StringBuilder();
      if (key == null) {
        if (logger.warningEnabled()) {
          logger.warning(
              LocalizedStrings.BaseCommand__THE_INPUT_KEY_FOR_THE_0_REQUEST_IS_NULL, "invalidate");
        }
        errMessage.append(
            LocalizedStrings.BaseCommand__THE_INPUT_KEY_FOR_THE_0_REQUEST_IS_NULL.toLocalizedString(
                "invalidate"));
      }
      if (regionName == null) {
        if (logger.warningEnabled()) {
          logger.warning(
              LocalizedStrings.BaseCommand__THE_INPUT_REGION_NAME_FOR_THE_0_REQUEST_IS_NULL,
              "invalidate");
        }
        errMessage.append(
            LocalizedStrings.BaseCommand__THE_INPUT_REGION_NAME_FOR_THE_0_REQUEST_IS_NULL
                .toLocalizedString("invalidate"));
      }
      writeErrorResponse(msg, MessageType.DESTROY_DATA_ERROR, errMessage.toString(), servConn);
      servConn.setAsTrue(RESPONDED);
    } else {
      LocalRegion region = (LocalRegion) crHelper.getRegion(regionName);
      if (region == null) {
        String reason =
            LocalizedStrings.BaseCommand__0_WAS_NOT_FOUND_DURING_1_REQUEST.toLocalizedString(
                regionName, "invalidate");
        writeRegionDestroyedEx(msg, regionName, reason, servConn);
        servConn.setAsTrue(RESPONDED);
      } else {
        // Invalidate the entry
        ByteBuffer eventIdPartsBuffer = ByteBuffer.wrap(eventPart.getSerializedForm());
        long threadId = EventID.readEventIdPartsFromOptmizedByteArray(eventIdPartsBuffer);
        long sequenceId = EventID.readEventIdPartsFromOptmizedByteArray(eventIdPartsBuffer);
        EventID eventId = new EventID(servConn.getEventMemberIDByteArray(), threadId, sequenceId);

        Breadcrumbs.setEventId(eventId);

        VersionTag tag = null;
        try {
          /*
           *
           * txtodo: doesn't seem like there is any notion of authzInvalidate
           */
          AuthorizeRequest authzRequest = servConn.getAuthzRequest();
          if (authzRequest != null) {
            InvalidateOperationContext invalidateContext =
                authzRequest.invalidateAuthorize(regionName, key, callbackArg);
            callbackArg = invalidateContext.getCallbackArg();
          }
          EntryEventImpl clientEvent = new EntryEventImpl(eventId);

          // msg.isRetry might be set by v7.0 and later clients
          if (msg.isRetry()) {
            //            if (logger.fineEnabled()) {
            //              logger.fine("DEBUG: encountered isRetry in Invalidate");
            //            }
            clientEvent.setPossibleDuplicate(true);
            if (region.getAttributes().getConcurrencyChecksEnabled()) {
              // recover the version tag from other servers
              clientEvent.setRegion(region);
              if (!recoverVersionTagForRetriedOperation(clientEvent)) {
                clientEvent.setPossibleDuplicate(false); // no-one has seen this event
              }
            }
          }

          region.basicBridgeInvalidate(key, callbackArg, servConn.getProxyID(), true, clientEvent);
          tag = clientEvent.getVersionTag();
          servConn.setModificationInfo(true, regionName, key);
        } catch (EntryNotFoundException e) {
          // Don't send an exception back to the client if this
          // exception happens. Just log it and continue.
          if (logger.infoEnabled()) {
            logger.info(
                LocalizedStrings.BaseCommand_DURING_0_NO_ENTRY_WAS_FOUND_FOR_KEY_1,
                new Object[] {"invalidate", key});
          }
        } catch (RegionDestroyedException rde) {
          writeException(msg, rde, false, servConn);
          servConn.setAsTrue(RESPONDED);
          return;
        } catch (Exception e) {
          // If an interrupted exception is thrown , rethrow it
          checkForInterrupt(servConn, e);

          // If an exception occurs during the destroy, preserve the connection
          writeException(msg, e, false, servConn);
          servConn.setAsTrue(RESPONDED);
          if (e instanceof GemFireSecurityException) {
            // Fine logging for security exceptions since these are already
            // logged by the security logger
            if (logger.fineEnabled())
              logger.fine(servConn.getName() + ": Unexpected Security exception", e);
          } else if (logger.warningEnabled()) {
            logger.warning(
                LocalizedStrings.BaseCommand_0_UNEXPECTED_EXCEPTION, servConn.getName(), e);
          }
          return;
        }

        // Update the statistics and write the reply
        {
          long oldStart = start;
          start = DistributionStats.getStatTime();
          stats.incProcessInvalidateTime(start - oldStart);
        }
        if (region instanceof PartitionedRegion) {
          PartitionedRegion pr = (PartitionedRegion) region;
          if (pr.isNetworkHop() != (byte) 0) {
            writeReplyWithRefreshMetadata(msg, servConn, pr, pr.isNetworkHop(), tag);
            pr.setIsNetworkHop((byte) 0);
            pr.setMetadataVersion(Byte.valueOf((byte) 0));
          } else {
            writeReply(msg, servConn, tag);
          }
        } else {
          writeReply(msg, servConn, tag);
        }
        servConn.setAsTrue(RESPONDED);
        if (logger.fineEnabled()) {
          logger.fine(
              servConn.getName()
                  + ": Sent invalidate response for region "
                  + regionName
                  + " key "
                  + key);
        }
        stats.incWriteInvalidateResponseTime(DistributionStats.getStatTime() - start);
      }
    }
  }
  @SuppressWarnings("unchecked")
  @Override
  public void cmdExecute(Message msg, ServerConnection servConn, long start)
      throws IOException, ClassNotFoundException, InterruptedException {
    String regionFullPath = null;
    CachedRegionHelper crHelper = servConn.getCachedRegionHelper();
    regionFullPath = msg.getPart(0).getString();
    String errMessage = "";
    if (regionFullPath == null) {
      logger.warn(
          LocalizedMessage.create(
              LocalizedStrings.GetClientPartitionAttributes_THE_INPUT_REGION_PATH_IS_NULL));
      errMessage =
          LocalizedStrings.GetClientPartitionAttributes_THE_INPUT_REGION_PATH_IS_NULL
              .toLocalizedString();
      writeErrorResponse(
          msg, MessageType.GET_CLIENT_PARTITION_ATTRIBUTES_ERROR, errMessage.toString(), servConn);
      servConn.setAsTrue(RESPONDED);
    } else {
      Region region = crHelper.getRegion(regionFullPath);
      if (region == null) {
        logger.warn(
            LocalizedMessage.create(
                LocalizedStrings
                    .GetClientPartitionAttributes_REGION_NOT_FOUND_FOR_SPECIFIED_REGION_PATH,
                regionFullPath));
        errMessage =
            LocalizedStrings.GetClientPartitionAttributes_REGION_NOT_FOUND.toLocalizedString()
                + regionFullPath;
        writeErrorResponse(
            msg,
            MessageType.GET_CLIENT_PARTITION_ATTRIBUTES_ERROR,
            errMessage.toString(),
            servConn);
        servConn.setAsTrue(RESPONDED);
      } else {
        try {
          Message responseMsg = servConn.getResponseMessage();
          responseMsg.setTransactionId(msg.getTransactionId());
          responseMsg.setMessageType(MessageType.RESPONSE_CLIENT_PARTITION_ATTRIBUTES);

          PartitionedRegion prRgion = (PartitionedRegion) region;

          PartitionResolver partitionResolver = prRgion.getPartitionResolver();
          int numParts = 2; // MINUMUM PARTS
          if (partitionResolver != null) {
            numParts++;
          }
          responseMsg.setNumberOfParts(numParts);
          // PART 1
          responseMsg.addObjPart(prRgion.getTotalNumberOfBuckets());

          // PART 2
          if (partitionResolver != null) {
            responseMsg.addObjPart(partitionResolver.getClass().toString().substring(6));
          }

          // PART 3
          String leaderRegionPath = null;
          PartitionedRegion leaderRegion = null;
          String leaderRegionName = prRgion.getColocatedWith();
          if (leaderRegionName != null) {
            Cache cache = prRgion.getCache();
            while (leaderRegionName != null) {
              leaderRegion = (PartitionedRegion) cache.getRegion(leaderRegionName);
              if (leaderRegion.getColocatedWith() == null) {
                leaderRegionPath = leaderRegion.getFullPath();
                break;
              } else {
                leaderRegionName = leaderRegion.getColocatedWith();
              }
            }
          }
          responseMsg.addObjPart(leaderRegionPath);
          responseMsg.send();
          msg.flush();
        } catch (Exception e) {
          writeException(msg, e, false, servConn);
        } finally {
          servConn.setAsTrue(Command.RESPONDED);
        }
      }
    }
  }