コード例 #1
0
  /**
   * Inserts the provided {@code statement} after the the node this inserter was created for. Tries
   * to put the {@code statement} as close to the {@code marker} as possible.
   *
   * @param statement The statement to insert after the insertion node.
   */
  void insertAfter(final Statement statement) {
    Validate.notNull(statement);
    Validate.validState(
        this.insertionList != null,
        "Insertion is only possible after the inserter has been set up.");
    Validate.validState(
        this.insertionList.isPresent(),
        "Insertion is only possible if setting up the inserter succeeded.");

    if (this.differentAfterList) {
      this.afterList.add(0, statement);
    } else if (this.breakDetector.containsControlFlowBreakingStatement(this.markedStatement)) {
      // we are trying to insert after a control flow breaking statement. That’s
      // dangerous, better surround with try…finally

      final AST factory = this.markedStatement.getAST();
      final TryStatement tryStatement = factory.newTryStatement();
      tryStatement.setFinally(factory.newBlock());

      @SuppressWarnings("unchecked")
      final List<Statement> tryBodyStatements = tryStatement.getBody().statements();
      @SuppressWarnings("unchecked")
      final List<Statement> finallyStatements = tryStatement.getFinally().statements();
      final Statement copy = (Statement) ASTNode.copySubtree(factory, this.markedStatement);
      tryBodyStatements.add(copy);
      finallyStatements.add(statement);
      this.insertionList.get().set(this.markerIndex, tryStatement);
      this.markedStatement = tryStatement;
      this.differentAfterList = true;
      this.afterList = finallyStatements;
    } else {
      this.insertionList.get().add(this.markerIndex, statement);
    }
  }
コード例 #2
0
  /**
   * Inserts the provided {@code statement} before the node this inserter was created for. Tries to
   * put the {@code statement} as close to the node as possible.
   *
   * @param statement The statement to insert before the insertion node.
   */
  void insertBefore(final Statement statement) {
    Validate.notNull(statement);
    Validate.validState(
        this.insertionList != null,
        "Insertion is only possible after the inserter has been set up.");
    Validate.validState(
        this.insertionList.isPresent(),
        "Insertion is only possible if setting up the inserter succeeded.");

    this.insertionList.get().add(this.markerIndex, statement);
    this.markerIndex++;
  }
コード例 #3
0
ファイル: MinecraftServer.java プロジェクト: McSwede/XIV
  private void addFaviconToStatusResponse(ServerStatusResponse response) {
    File var2 = this.getFile("server-icon.png");

    if (var2.isFile()) {
      ByteBuf var3 = Unpooled.buffer();

      try {
        BufferedImage var4 = ImageIO.read(var2);
        Validate.validState(var4.getWidth() == 64, "Must be 64 pixels wide", new Object[0]);
        Validate.validState(var4.getHeight() == 64, "Must be 64 pixels high", new Object[0]);
        ImageIO.write(var4, "PNG", new ByteBufOutputStream(var3));
        ByteBuf var5 = Base64.encode(var3);
        response.setFavicon("data:image/png;base64," + var5.toString(Charsets.UTF_8));
      } catch (Exception var9) {
        logger.error("Couldn\'t load server icon", var9);
      } finally {
        var3.release();
      }
    }
  }
コード例 #4
0
  private void a(ServerPing serverping) {
    File file = this.d("server-icon.png");

    if (file.isFile()) {
      ByteBuf bytebuf = Unpooled.buffer();

      try {
        BufferedImage bufferedimage = ImageIO.read(file);

        Validate.validState(
            bufferedimage.getWidth() == 64, "Must be 64 pixels wide", new Object[0]);
        Validate.validState(
            bufferedimage.getHeight() == 64, "Must be 64 pixels high", new Object[0]);
        ImageIO.write(bufferedimage, "PNG", new ByteBufOutputStream(bytebuf));
        ByteBuf bytebuf1 = Base64.encode(bytebuf);

        serverping.setFavicon("data:image/png;base64," + bytebuf1.toString(Charsets.UTF_8));
      } catch (Exception exception) {
        MinecraftServer.LOGGER.error("Couldn\'t load server icon", exception);
      } finally {
        bytebuf.release();
      }
    }
  }
コード例 #5
0
 @Override
 public GenericValue transformOne(
     final String entityName,
     final EntityCondition entityCondition,
     final String lockField,
     final Transformation transformation) {
   final List<GenericValue> transformedValues =
       transform(entityName, entityCondition, null, lockField, transformation);
   Validate.validState(
       transformedValues.size() == 1,
       "Expected one match for %s but found %d: %s",
       entityCondition,
       transformedValues.size(),
       transformedValues);
   return transformedValues.get(0);
 }
コード例 #6
0
  public void processLoginStart(C00PacketLoginStart packetIn) {
    Validate.validState(
        this.currentLoginState == NetHandlerLoginServer.LoginState.HELLO,
        "Unexpected hello packet",
        new Object[0]);
    this.loginGameProfile = packetIn.getProfile();

    if (this.server.isServerInOnlineMode() && !this.networkManager.isLocalChannel()) {
      this.currentLoginState = NetHandlerLoginServer.LoginState.KEY;
      this.networkManager.sendPacket(
          new S01PacketEncryptionRequest(
              this.serverId, this.server.getKeyPair().getPublic(), this.field_147330_e));
    } else {
      this.currentLoginState = NetHandlerLoginServer.LoginState.READY_TO_ACCEPT;
    }
  }
コード例 #7
0
 /** 检查ApplicationContext不为空. */
 private static void assertContextInjected() {
   Validate.validState(
       applicationContext != null,
       "applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder.");
 }
コード例 #8
0
  public void processEncryptionResponse(C01PacketEncryptionResponse packetIn) {
    Validate.validState(
        this.currentLoginState == NetHandlerLoginServer.LoginState.KEY,
        "Unexpected key packet",
        new Object[0]);
    PrivateKey var2 = this.server.getKeyPair().getPrivate();

    if (!Arrays.equals(this.field_147330_e, packetIn.func_149299_b(var2))) {
      throw new IllegalStateException("Invalid nonce!");
    } else {
      this.secretKey = packetIn.func_149300_a(var2);
      this.currentLoginState = NetHandlerLoginServer.LoginState.AUTHENTICATING;
      this.networkManager.enableEncryption(this.secretKey);
      (new Thread("User Authenticator #" + AUTHENTICATOR_THREAD_ID.incrementAndGet()) {
            private static final String __OBFID = "CL_00002268";

            public void run() {
              GameProfile var1 = NetHandlerLoginServer.this.loginGameProfile;

              try {
                String var2 =
                    (new BigInteger(
                            CryptManager.getServerIdHash(
                                NetHandlerLoginServer.this.serverId,
                                NetHandlerLoginServer.this.server.getKeyPair().getPublic(),
                                NetHandlerLoginServer.this.secretKey)))
                        .toString(16);
                NetHandlerLoginServer.this.loginGameProfile =
                    NetHandlerLoginServer.this
                        .server
                        .getMinecraftSessionService()
                        .hasJoinedServer(new GameProfile((UUID) null, var1.getName()), var2);

                if (NetHandlerLoginServer.this.loginGameProfile != null) {
                  NetHandlerLoginServer.logger.info(
                      "UUID of player "
                          + NetHandlerLoginServer.this.loginGameProfile.getName()
                          + " is "
                          + NetHandlerLoginServer.this.loginGameProfile.getId());
                  NetHandlerLoginServer.this.currentLoginState =
                      NetHandlerLoginServer.LoginState.READY_TO_ACCEPT;
                } else if (NetHandlerLoginServer.this.server.isSinglePlayer()) {
                  NetHandlerLoginServer.logger.warn(
                      "Failed to verify username but will let them in anyway!");
                  NetHandlerLoginServer.this.loginGameProfile =
                      NetHandlerLoginServer.this.getOfflineProfile(var1);
                  NetHandlerLoginServer.this.currentLoginState =
                      NetHandlerLoginServer.LoginState.READY_TO_ACCEPT;
                } else {
                  NetHandlerLoginServer.this.closeConnection("Failed to verify username!");
                  NetHandlerLoginServer.logger.error(
                      "Username \'"
                          + NetHandlerLoginServer.this.loginGameProfile.getName()
                          + "\' tried to join with an invalid session");
                }
              } catch (AuthenticationUnavailableException var3) {
                if (NetHandlerLoginServer.this.server.isSinglePlayer()) {
                  NetHandlerLoginServer.logger.warn(
                      "Authentication servers are down but will let them in anyway!");
                  NetHandlerLoginServer.this.loginGameProfile =
                      NetHandlerLoginServer.this.getOfflineProfile(var1);
                  NetHandlerLoginServer.this.currentLoginState =
                      NetHandlerLoginServer.LoginState.READY_TO_ACCEPT;
                } else {
                  NetHandlerLoginServer.this.closeConnection(
                      "Authentication servers are down. Please try again later, sorry!");
                  NetHandlerLoginServer.logger.error(
                      "Couldn\'t verify username because servers are unavailable");
                }
              }
            }
          })
          .start();
    }
  }
コード例 #9
0
  private Table updateOrDeleteManagedEntity(
      final ClassOrInterfaceTypeDetails managedEntity, final Database database) {
    // Update the attributes of the existing JPA-related annotation
    final AnnotationMetadata jpaAnnotation = getJpaAnnotation(managedEntity);
    Validate.validState(
        jpaAnnotation != null,
        "Neither @%s nor @%s found on existing DBRE-managed entity %s",
        ROO_JPA_ACTIVE_RECORD.getSimpleTypeName(),
        ROO_JPA_ENTITY.getSimpleTypeName(),
        managedEntity.getName().getFullyQualifiedTypeName());

    // Find table in database using 'table' and 'schema' attributes from the
    // JPA annotation
    final AnnotationAttributeValue<?> tableAttribute =
        jpaAnnotation.getAttribute(new JavaSymbolName("table"));
    final String errMsg =
        "Unable to maintain database-managed entity "
            + managedEntity.getName().getFullyQualifiedTypeName()
            + " because its associated table could not be found";
    Validate.notNull(tableAttribute, errMsg);
    final String tableName = (String) tableAttribute.getValue();
    Validate.notBlank(tableName, errMsg);

    final AnnotationAttributeValue<?> schemaAttribute =
        jpaAnnotation.getAttribute(new JavaSymbolName("schema"));
    final String schemaName = schemaAttribute != null ? (String) schemaAttribute.getValue() : null;

    final Table table = database.getTable(tableName, schemaName);
    if (table == null) {
      // Table is missing and probably has been dropped so delete managed
      // type and its identifier if applicable
      deleteManagedType(managedEntity, "no database table called '" + tableName + "'");
      return null;
    }

    table.setIncludeNonPortableAttributes(database.isIncludeNonPortableAttributes());
    table.setDisableVersionFields(database.isDisableVersionFields());
    table.setDisableGeneratedIdentifiers(database.isDisableGeneratedIdentifiers());

    // Update the @RooJpaEntity/@RooJpaActiveRecord attributes
    final AnnotationMetadataBuilder jpaAnnotationBuilder =
        new AnnotationMetadataBuilder(jpaAnnotation);
    final Set<JavaSymbolName> attributesToDeleteIfPresent = new LinkedHashSet<JavaSymbolName>();
    manageIdentifier(
        managedEntity.getName(), jpaAnnotationBuilder, attributesToDeleteIfPresent, table);

    // Manage versionField attribute
    final AnnotationAttributeValue<?> versionFieldAttribute =
        jpaAnnotation.getAttribute(new JavaSymbolName(VERSION_FIELD));
    if (versionFieldAttribute == null) {
      if (hasVersionField(table)) {
        attributesToDeleteIfPresent.add(new JavaSymbolName(VERSION_FIELD));
      } else {
        jpaAnnotationBuilder.addStringAttribute(VERSION_FIELD, "");
      }
    } else {
      final String versionFieldValue = (String) versionFieldAttribute.getValue();
      if (hasVersionField(table)
          && (StringUtils.isBlank(versionFieldValue) || VERSION.equals(versionFieldValue))) {
        attributesToDeleteIfPresent.add(new JavaSymbolName(VERSION_FIELD));
      }
    }

    final AnnotationAttributeValue<?> sequenceNameFieldAttribute =
        jpaAnnotation.getAttribute(new JavaSymbolName(SEQUENCE_NAME_FIELD));
    if (sequenceNameFieldAttribute == null) {
      if (!table.isDisableGeneratedIdentifiers()) {
        attributesToDeleteIfPresent.add(new JavaSymbolName(SEQUENCE_NAME_FIELD));
      } else {
        jpaAnnotationBuilder.addStringAttribute(SEQUENCE_NAME_FIELD, "");
      }
    } else {
      final String sequenceNameFieldValue = (String) sequenceNameFieldAttribute.getValue();
      if (!table.isDisableGeneratedIdentifiers() && ("".equals(sequenceNameFieldValue))) {
        attributesToDeleteIfPresent.add(new JavaSymbolName(SEQUENCE_NAME_FIELD));
      }
    }

    // Update the annotation on disk
    final ClassOrInterfaceTypeDetailsBuilder cidBuilder =
        new ClassOrInterfaceTypeDetailsBuilder(managedEntity);
    cidBuilder.updateTypeAnnotation(jpaAnnotationBuilder.build(), attributesToDeleteIfPresent);
    typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());
    return table;
  }