예제 #1
0
  /** Test method getPattern */
  @Test
  @SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION")
  public void testGetPattern() {
    assertNotNull(RegExPool.getPattern("xy"));
    assertSame(RegExPool.getPattern("xy"), RegExPool.getPattern("xy"));
    assertNotSame(RegExPool.getPattern("xy"), RegExPool.getPattern("yy"));

    try {
      // empty string not allowed
      RegExPool.getPattern("");
      fail();
    } catch (final IllegalArgumentException ex) {
    }

    try {
      // null not allowed
      RegExPool.getPattern(null);
      fail();
    } catch (final NullPointerException ex) {
    }

    try {
      // Illegal regular expression
      RegExPool.getPattern("[a-z+");
      fail();
    } catch (final IllegalArgumentException ex) {
      assertNotNull(ex.getCause());
      assertTrue(ex.getCause() instanceof PatternSyntaxException);
    }
  }
 @Test
 public void testThrowMessageForMessageOnViolation() throws Exception {
   final ParametersPassesExpression annotation =
       proxyAnnotation(
           ParametersPassesExpression.class,
           "value",
           "myExpression",
           "messageOnViolation",
           "My message - ${#expression}");
   final MethodCall<ParametersPassesExpressionUnitTest> methodCall =
       toMethodCall(ParametersPassesExpressionUnitTest.class, this, "test", "a", 1, "b", 2);
   try {
     new Evaluator().throwMessageFor(annotation, methodCall, null);
     fail("Exception missing");
   } catch (IllegalArgumentException e) {
     assertThat(e.getMessage(), is("My message - " + annotation.value()));
     assertThat(e.getCause(), nullValue());
   }
   final Throwable cause = new Throwable("myCause");
   try {
     new Evaluator().throwMessageFor(annotation, methodCall, cause);
     fail("Exception missing");
   } catch (IllegalArgumentException e) {
     assertThat(e.getMessage(), is("My message - " + annotation.value()));
     assertThat(e.getCause(), is(cause));
   }
 }
예제 #3
0
 @Override
 public long isReady(long tid, Master environment) throws Exception {
   try {
     String namespaceId = Tables.getNamespaceId(environment.getInstance(), tableId);
     return Utils.reserveNamespace(namespaceId, tid, false, false, TableOperation.DELETE)
         + Utils.reserveTable(tableId, tid, true, true, TableOperation.DELETE);
   } catch (IllegalArgumentException ex) {
     if (ex.getCause() != null && ex.getCause() instanceof TableNotFoundException) {
       return 0;
     }
     throw ex;
   }
 }
예제 #4
0
 @Override
 public Repo<Master> call(long tid, Master environment) throws Exception {
   try {
     String namespaceId = Tables.getNamespaceId(environment.getInstance(), tableId);
     TableManager.getInstance().transitionTableState(tableId, TableState.DELETING);
     environment.getEventCoordinator().event("deleting table %s ", tableId);
     return new CleanUp(tableId, namespaceId);
   } catch (IllegalArgumentException ex) {
     if (ex.getCause() != null && ex.getCause() instanceof TableNotFoundException) {
       return null;
     }
     throw ex;
   }
 }
예제 #5
0
파일: FunLib.java 프로젝트: jgralab/jgralab
 public static final Object apply(FunctionInfo fi, Object... args) {
   assert fi != null;
   if (!fi.acceptsUndefinedValues) {
     for (Object arg : args) {
       if ((arg == null) || (arg == Undefined.UNDEFINED)) {
         return Undefined.UNDEFINED;
       }
     }
   }
   for (Signature sig : fi.signatures) {
     if (sig.matches(args)) {
       try {
         Object result = sig.evaluateMethod.invoke(fi.function, args);
         assert Types.isValidGreqlValue(result);
         return result == null ? Undefined.UNDEFINED : result;
       } catch (IllegalArgumentException e) {
         if (e.getCause() instanceof GreqlException) {
           throw (GreqlException) e.getCause();
         } else {
           throw new GreqlException(
               "When applying function " + fi.name + ": " + e.getMessage(), e.getCause());
         }
       } catch (IllegalAccessException e) {
         if (e.getCause() instanceof GreqlException) {
           throw (GreqlException) e.getCause();
         } else {
           throw new GreqlException(
               "When applying function " + fi.name + ": " + e.getMessage(), e.getCause());
         }
       } catch (InvocationTargetException e) {
         if (e.getCause() instanceof GreqlException) {
           throw (GreqlException) e.getCause();
         } else {
           throw new GreqlException(
               "When applying function " + fi.name + ": " + e.getMessage(), e.getCause());
         }
       }
     }
   }
   StringBuilder sb = new StringBuilder();
   sb.append("Function '").append(fi.name).append("' not defined for argument types (");
   String delim = "";
   for (Object arg : args) {
     sb.append(delim).append(Types.getGreqlTypeName(arg));
     delim = ", ";
   }
   sb.append(")");
   throw new GreqlException(sb.toString());
 }
  public void testAliasInvalidFilterValidJson() throws Exception {
    // invalid filter but valid json: put index template works fine, fails during index creation
    client()
        .admin()
        .indices()
        .preparePutTemplate("template_1")
        .setTemplate("te*")
        .addAlias(new Alias("invalid_alias").filter("{ \"invalid\": {} }"))
        .get();

    GetIndexTemplatesResponse response =
        client().admin().indices().prepareGetTemplates("template_1").get();
    assertThat(response.getIndexTemplates().size(), equalTo(1));
    assertThat(response.getIndexTemplates().get(0).getAliases().size(), equalTo(1));
    assertThat(
        response.getIndexTemplates().get(0).getAliases().get("invalid_alias").filter().string(),
        equalTo("{\"invalid\":{}}"));

    try {
      createIndex("test");
      fail(
          "index creation should have failed due to invalid alias filter in matching index template");
    } catch (IllegalArgumentException e) {
      assertThat(e.getMessage(), equalTo("failed to parse filter for alias [invalid_alias]"));
      assertThat(e.getCause(), instanceOf(ParsingException.class));
      assertThat(e.getCause().getMessage(), equalTo("No query registered for [invalid]"));
    }
  }
예제 #7
0
파일: Client.java 프로젝트: evri/iudex
      private String lastURL() throws URISyntaxException {
        try {
          Address adr = getAddress();
          String scheme = decode(getScheme()).toString();
          int port = adr.getPort();
          if ((scheme.equals("http") && port == 80) || (scheme.equals("https") && port == 443)) {
            port = -1;
          }

          URI uri = new URI(scheme, null, adr.getHost(), port, null, null, null);

          uri = uri.resolve(getRequestURI());
          return uri.toString();
        }
        // URI can also throw IllegalArgumentException wrapping
        // a URISyntaxException. Unwrap it.
        catch (IllegalArgumentException x) {
          Throwable cause = x.getCause();
          if ((cause != null) && (cause instanceof URISyntaxException)) {
            throw (URISyntaxException) cause;
          } else {
            throw x;
          }
        }
      }
  /** Send the event notification. */
  public void notify(T event) {
    Object instance = getInstance();

    if (instance == null) return;

    Method method = _method.getJavaMember();

    try {
      method.invoke(instance, getEventArguments(event));
    } catch (IllegalArgumentException e) {
      String loc = (method.getDeclaringClass().getSimpleName() + "." + method.getName() + ": ");

      throw new InjectionException(loc + e.getMessage(), e.getCause());
    } catch (RuntimeException e) {
      throw e;
    } catch (InvocationTargetException e) {
      String loc = (method.getDeclaringClass().getSimpleName() + "." + method.getName() + ": ");

      throw new InjectionException(loc + e.getMessage(), e.getCause());
    } catch (Exception e) {
      String loc = (method.getDeclaringClass().getSimpleName() + "." + method.getName() + ": ");

      throw new InjectionException(loc + e.getMessage(), e.getCause());
    }
  }
예제 #9
0
 @ExceptionHandler(IllegalArgumentException.class)
 ResponseEntity<String> sendBadRequestException(IllegalArgumentException ex) {
   LOGGER.warn(
       "Exception was thrown, with cause "
           + ex.getCause()
           + "\nMessage: "
           + ex.getLocalizedMessage(),
       ex);
   return new ResponseEntity<>(ex.getLocalizedMessage(), HttpStatus.BAD_REQUEST);
 }
예제 #10
0
  public void testHeaderMissingFile() throws Exception {
    final String missing = "no-such-file";
    final String alias = "missing";
    final String charsetName = "UTF-8";

    try {
      FS.reserveFile(missing, charsetName, alias, true);
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
      assertTrue("Expected FNF", e.getCause() instanceof java.io.FileNotFoundException);
    }
    // Ensure second invocation gets same behaviour
    try {
      FS.reserveFile(missing, charsetName, alias, true);
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
      assertTrue("Expected FNF", e.getCause() instanceof java.io.FileNotFoundException);
    }
  }
예제 #11
0
  public void testHeaderEmptyFile() throws Exception {
    final String empty = findTestPath("testfiles/empty.csv");
    final String alias = "empty";
    final String charsetName = "UTF-8";

    try {
      String hdr = FS.reserveFile(empty, charsetName, alias, true);
      fail("Expected IllegalArgumentException|" + hdr + "|");
    } catch (IllegalArgumentException e) {
      assertTrue("Expected EOF", e.getCause() instanceof java.io.EOFException);
    }
    // Ensure second invocation gets same behaviour
    try {
      FS.reserveFile(empty, charsetName, alias, true);
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
      assertTrue("Expected EOF", e.getCause() instanceof java.io.EOFException);
    }
  }
예제 #12
0
 private boolean askedForStop() {
   File tempDir = fileSystem.getTempDir();
   try (DefaultProcessCommands processCommands =
       new DefaultProcessCommands(tempDir, CURRENT_PROCESS_NUMBER, false)) {
     if (processCommands.askedForStop()) {
       return true;
     }
   } catch (IllegalArgumentException e) {
     // DefaultProcessCommand currently wraps IOException into a IllegalArgumentException
     // accessing the shared memory file may fail if a restart is in progress and the temp
     // directory
     // is currently deleted and not yet recreated
     if (e.getCause() instanceof IOException) {
       ignore((IOException) e.getCause());
     } else {
       rethrow(e);
     }
   } catch (Exception e) {
     rethrow(e);
   }
   return false;
 }
예제 #13
0
  /**
   * Create move refactoring session.
   *
   * @param cmr move settings, contains resource paths to move.
   * @return refactoring session id.
   * @throws JavaModelException when JavaModel has a failure
   * @throws RefactoringException when impossible to create move refactoring session
   */
  @POST
  @Path("move/create")
  @Consumes("application/json")
  @Produces("text/plain")
  public String createMoveRefactoring(CreateMoveRefactoring cmr)
      throws JavaModelException, RefactoringException {
    IJavaProject javaProject = model.getJavaProject(cmr.getProjectPath());
    IJavaElement[] javaElements;
    try {
      Function<ElementToMove, IJavaElement> map =
          javaElement -> {
            try {
              if (javaElement.isPack()) {
                return javaProject.findPackageFragment(
                    new org.eclipse.core.runtime.Path(javaElement.getPath()));
              } else {
                return javaProject.findType(javaElement.getPath()).getCompilationUnit();
              }
            } catch (JavaModelException e) {
              throw new IllegalArgumentException(e);
            }
          };
      javaElements = cmr.getElements().stream().map(map).toArray(IJavaElement[]::new);

    } catch (IllegalArgumentException e) {
      if (e.getCause() instanceof JavaModelException) {
        throw (JavaModelException) e.getCause();
      } else {
        throw e;
      }
    }
    if (RefactoringAvailabilityTester.isMoveAvailable(new IResource[0], javaElements)) {
      return manager.createMoveRefactoringSession(javaElements);
    }

    throw new RefactoringException("Can't create move refactoring.");
  }
예제 #14
0
  private Object getValueOfField(String fieldname, Class<?> sourceClass, Object source) {
    String sourceClassName = sourceClass.getName();

    Field field = null;
    try {
      field = sourceClass.getDeclaredField(fieldname);
      field.setAccessible(true);
    } catch (SecurityException e) {
      fail(
          "Unable to retrieve "
              + fieldname
              + " field from "
              + sourceClassName
              + ": "
              + e.getCause());
    } catch (NoSuchFieldException e) {
      fail(
          "Unable to retrieve "
              + fieldname
              + " field from "
              + sourceClassName
              + ": "
              + e.getCause());
    }

    assertNotNull("." + fieldname + " field is null!?!", field);
    Object fieldValue = null;
    try {
      fieldValue = field.get(source);
    } catch (IllegalArgumentException e) {
      fail(
          "Unable to retrieve value of "
              + fieldname
              + " from "
              + sourceClassName
              + ": "
              + e.getCause());
    } catch (IllegalAccessException e) {
      fail(
          "Unable to retrieve value of "
              + fieldname
              + " from "
              + sourceClassName
              + ": "
              + e.getCause());
    }
    return fieldValue;
  }
  /**
   * Parse, validate and set native JE environment properties for a given environment config.
   *
   * @param envConfig The JE environment config for which to set the properties.
   * @param jeProperties The JE environment properties to parse, validate and set.
   * @param configAttrMap Component supported JE properties to their configuration attributes map.
   * @return An environment config instance with given properties set.
   * @throws ConfigException If there is an error while parsing, validating and setting any of the
   *     properties provided.
   */
  public static EnvironmentConfig setJEProperties(
      EnvironmentConfig envConfig,
      SortedSet<String> jeProperties,
      HashMap<String, String> configAttrMap)
      throws ConfigException {
    if (jeProperties.isEmpty()) {
      // return default config.
      return envConfig;
    }

    // Set to catch duplicate properties.
    HashSet<String> uniqueJEProperties = new HashSet<>();

    // Iterate through the config values associated with a JE property.
    for (String jeEntry : jeProperties) {
      StringTokenizer st = new StringTokenizer(jeEntry, "=");
      if (st.countTokens() != 2) {
        throw new ConfigException(ERR_CONFIG_JE_PROPERTY_INVALID_FORM.get(jeEntry));
      }

      String jePropertyName = st.nextToken();
      String jePropertyValue = st.nextToken();
      // Check if it is a duplicate.
      if (uniqueJEProperties.contains(jePropertyName)) {
        throw new ConfigException(ERR_CONFIG_JE_DUPLICATE_PROPERTY.get(jePropertyName));
      }

      // Set JE property.
      try {
        envConfig.setConfigParam(jePropertyName, jePropertyValue);
        // If this property shadows an existing config attribute.
        if (configAttrMap.containsKey(jePropertyName)) {
          LocalizableMessage message =
              ERR_CONFIG_JE_PROPERTY_SHADOWS_CONFIG.get(
                  jePropertyName, attrMap.get(jePropertyName));
          throw new ConfigException(message);
        }
        // Add this property to unique set.
        uniqueJEProperties.add(jePropertyName);
      } catch (IllegalArgumentException e) {
        logger.traceException(e);
        LocalizableMessage message = ERR_CONFIG_JE_PROPERTY_INVALID.get(jeEntry, e.getMessage());
        throw new ConfigException(message, e.getCause());
      }
    }

    return envConfig;
  }
예제 #16
0
  public void testGetAttribute() throws Exception {
    RawAttributeMapper rawMapper = RawAttributeMapper.of(setupGenRule());
    List<Label> value = rawMapper.get("data", BuildType.LABEL_LIST);
    assertNotNull(value);
    assertThat(value).containsExactly(Label.create("x", "data_a"), Label.create("x", "data_b"));

    // Configurable attribute: trying to directly access from a RawAttributeMapper throws a
    // type mismatch exception.
    try {
      rawMapper.get("srcs", BuildType.LABEL_LIST);
      fail("Expected srcs lookup to fail since the returned type is a SelectorList and not a list");
    } catch (IllegalArgumentException e) {
      assertThat(e.getCause().getMessage())
          .contains("SelectorList cannot be cast to java.util.List");
    }
  }
예제 #17
0
 /** Tests that RawAttributeMapper can't handle label visitation with configurable attributes. */
 public void testVisitLabels() throws Exception {
   RawAttributeMapper rawMapper = RawAttributeMapper.of(setupGenRule());
   try {
     rawMapper.visitLabels(
         new AttributeMap.AcceptsLabelAttribute() {
           @Override
           public void acceptLabelAttribute(Label label, Attribute attribute) {
             // Nothing to do.
           }
         });
     fail("Expected label visitation to fail since one attribute is configurable");
   } catch (IllegalArgumentException e) {
     assertThat(e.getCause().getMessage())
         .contains("SelectorList cannot be cast to java.util.List");
   }
 }
 @Test
 public void testEvaluationThrowsException() throws Exception {
   final MethodCall<ParametersPassesExpressionUnitTest> methodCall =
       toMethodCall(ParametersPassesExpressionUnitTest.class, this, "test", "a", 1, "b", '2');
   try {
     new Evaluator()
         .evaluate(
             proxyAnnotation(ParametersPassesExpression.class, "value", "a eq b"),
             METHOD,
             "test",
             methodCall);
     fail("Expected exception missing.");
   } catch (IllegalArgumentException e) {
     assertThat(e.getMessage(), is("Expression not passed: a eq b"));
     assertThat(e.getCause() instanceof SpelEvaluationException, is(true));
   }
 }
 private static MXBeanProxy findMXBeanProxy(Class<?> mxbeanInterface) {
   synchronized (mxbeanProxies) {
     WeakReference<MXBeanProxy> proxyRef = mxbeanProxies.get(mxbeanInterface);
     MXBeanProxy p = (proxyRef == null) ? null : proxyRef.get();
     if (p == null) {
       try {
         p = new MXBeanProxy(mxbeanInterface);
       } catch (IllegalArgumentException e) {
         String msg =
             "Cannot make MXBean proxy for " + mxbeanInterface.getName() + ": " + e.getMessage();
         IllegalArgumentException iae = new IllegalArgumentException(msg, e.getCause());
         iae.setStackTrace(e.getStackTrace());
         throw iae;
       }
       mxbeanProxies.put(mxbeanInterface, new WeakReference<MXBeanProxy>(p));
     }
     return p;
   }
 }
  public void testUpdateSettingsCanNotChangeThreadPoolType() throws InterruptedException {
    String threadPoolName = randomThreadPoolName();
    ThreadPool.ThreadPoolType invalidThreadPoolType = randomIncorrectThreadPoolType(threadPoolName);
    ThreadPool.ThreadPoolType validThreadPoolType =
        ThreadPool.THREAD_POOL_TYPES.get(threadPoolName);
    ThreadPool threadPool = null;
    try {
      threadPool =
          new ThreadPool(
              Settings.builder()
                  .put("node.name", "testUpdateSettingsCanNotChangeThreadPoolType")
                  .build());
      ClusterSettings clusterSettings =
          new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
      threadPool.setClusterSettings(clusterSettings);

      clusterSettings.applySettings(
          Settings.builder()
              .put("threadpool." + threadPoolName + ".type", invalidThreadPoolType.getType())
              .build());
      fail("expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
      assertEquals(
          "illegal value can't update [threadpool.] from [{}] to [{"
              + threadPoolName
              + ".type="
              + invalidThreadPoolType.getType()
              + "}]",
          e.getMessage());
      assertThat(
          e.getCause().getMessage(),
          is(
              "setting threadpool."
                  + threadPoolName
                  + ".type to "
                  + invalidThreadPoolType.getType()
                  + " is not permitted; must be "
                  + validThreadPoolType.getType()));
    } finally {
      terminateThreadPoolIfNeeded(threadPool);
    }
  }
 @Test
 public void unsupportedResponseTypesNotMatched() {
   try {
     service.object();
     fail();
   } catch (IllegalArgumentException e) {
     assertThat(e)
         .hasMessage(
             ""
                 + "Unable to create converter for class java.lang.Object\n"
                 + "    for method Service.object");
     assertThat(e.getCause())
         .hasMessage(
             ""
                 + "Could not locate ResponseBody converter for class java.lang.Object.\n"
                 + "  Tried:\n"
                 + "   * retrofit2.BuiltInConverters\n"
                 + "   * retrofit2.converter.scalars.ScalarsConverterFactory");
   }
 }
예제 #22
0
  @Test
  public void testParsedFilter() {
    String q1 = "@cluster = \"cluster1\" and @datacenter = \"dc1\" and @field3 = 100000";
    try {
      FilterList filterList = (FilterList) buildFilter(q1);
      Assert.assertEquals(FilterList.Operator.MUST_PASS_ONE, filterList.getOperator());
      Assert.assertEquals(1, filterList.getFilters().size());
      Assert.assertEquals(2, ((FilterList) filterList.getFilters().get(0)).getFilters().size());
    } catch (EagleQueryParseException e) {
      Assert.fail(e.getMessage());
    }

    String q2 =
        "@cluster = \"cluster1\" and @datacenter = \"dc1\" and ( @field3 = 100000 or @field3 < 100000)";
    try {
      FilterList filterList = (FilterList) buildFilter(q2);
      Assert.assertEquals(FilterList.Operator.MUST_PASS_ONE, filterList.getOperator());
      Assert.assertEquals(2, filterList.getFilters().size());
      Assert.assertEquals(2, ((FilterList) filterList.getFilters().get(0)).getFilters().size());
    } catch (EagleQueryParseException e) {
      Assert.fail(e.getMessage());
    }

    // Test parse success but bad type of value
    String q3 =
        "@cluster = \"cluster1\" and @datacenter = \"dc1\" and ( @field3 = 100000 or @field3 < \"bad_int_100000\")";
    boolean q3Ex = false;
    try {
      Assert.assertNull(buildFilter(q3));
    } catch (EagleQueryParseException e) {
      Assert.fail(e.getMessage());
    } catch (IllegalArgumentException e) {
      LOG.debug("Expect: ", e);
      Assert.assertTrue(e.getCause() instanceof NumberFormatException);
      q3Ex = true;
    }
    Assert.assertTrue(q3Ex);
  }
예제 #23
0
 public Iterator<Authorizable> execute(final String query)
     throws RepositoryException, IOException {
   try {
     return userManager.findAuthorizables(
         new Query() {
           public <T> void build(QueryBuilder<T> builder) {
             try {
               // Must request more than MAX_RESULT_COUNT records explicitly
               builder.setLimit(0, MAX_RESULT_COUNT);
               new QueryTranslator<T>(builder).translate(query);
             } catch (IOException e) {
               throw new IllegalArgumentException(e);
             }
           }
         });
   } catch (IllegalArgumentException e) {
     Throwable cause = e.getCause();
     if (cause instanceof IOException) {
       throw (IOException) cause;
     } else {
       throw e;
     }
   }
 }
예제 #24
0
파일: Context.java 프로젝트: pensz/hive
  /** Create a map-reduce scratch directory on demand and return it. */
  public String getMRScratchDir() {

    // if we are executing entirely on the client side - then
    // just (re)use the local scratch directory
    if (isLocalOnlyExecutionMode()) {
      return getLocalScratchDir(!explain);
    }

    try {
      Path dir = FileUtils.makeQualified(nonLocalScratchPath, conf);
      URI uri = dir.toUri();
      return getScratchDir(uri.getScheme(), uri.getAuthority(), !explain, uri.getPath());

    } catch (IOException e) {
      throw new RuntimeException(e);
    } catch (IllegalArgumentException e) {
      throw new RuntimeException(
          "Error while making MR scratch "
              + "directory - check filesystem config ("
              + e.getCause()
              + ")",
          e);
    }
  }
  /* UT */ IteratorSearchResponse searchByTerms(
      final Map<String, String> terms,
      final String repositoryId,
      final Integer from,
      final int count,
      final Boolean exact,
      final Boolean expandVersion,
      final Boolean collapseResults,
      final List<ArtifactInfoFilter> filters,
      final List<Searcher> searchers)
      throws NoSuchRepositoryException, ResourceException, IOException {
    try {
      for (Searcher searcher : searchers) {
        if (searcher.canHandle(terms)) {
          SearchType searchType = searcher.getDefaultSearchType();

          if (exact != null) {
            if (exact) {
              searchType = SearchType.EXACT;
            } else {
              searchType = SearchType.SCORED;
            }
          }

          // copy the list, to be able to modify it but do not interleave with potential recursive
          // calls
          List<ArtifactInfoFilter> actualFilters = new ArrayList<ArtifactInfoFilter>(filters);

          if (collapseResults) {
            // filters should affect only Keyword and GAVSearch!
            // TODO: maybe we should left this to the given Searcher implementation to handle (like
            // kw and gav
            // searcher is)
            // Downside would be that REST query params would be too far away from incoming call
            // (too spread)
            if (searcher instanceof KeywordSearcher
                || searcher instanceof MavenCoordinatesSearcher) {
              UniqueArtifactFilterPostprocessor filter = new UniqueArtifactFilterPostprocessor();

              filter.addField(MAVEN.GROUP_ID);
              filter.addField(MAVEN.ARTIFACT_ID);
              filter.addField(MAVEN.PACKAGING);
              filter.addField(MAVEN.CLASSIFIER);
              filter.addField(MAVEN.REPOSITORY_ID);

              if (Boolean.TRUE.equals(expandVersion)) {
                filter.addField(MAVEN.VERSION);
              }

              // add this last, to collapse results but _after_ collectors collects!
              actualFilters.add(filter);
            }
          }

          final IteratorSearchResponse searchResponse =
              searcher.flatIteratorSearch(
                  terms, repositoryId, from, count, null, false, searchType, actualFilters);

          if (searchResponse != null) {
            if (collapseResults
                && searchResponse.getTotalHitsCount() < COLLAPSE_OVERRIDE_TRESHOLD) {
              searchResponse.close();

              // FIXME: fix this, this is ugly
              // We are returning null, to hint that we need UNCOLLAPSED search!
              // Needed, to be able to "signal" the fact that we are overriding collapsed switch
              // since we have to send it back in DTOs to REST client
              return null;

              // old code was a recursive call:
              // this was a "collapsed" search (probably initiated by UI), and we have less then
              // treshold hits
              // override collapse
              // return searchByTerms( terms, repositoryId, from, count, exact, expandVersion,
              // false, filters
              // );
            } else {
              return searchResponse;
            }
          }
        }
      }
    } catch (IllegalArgumentException e) {
      if (e.getCause() instanceof ParseException) {
        // NEXUS-4372: illegal query -> 400 response
        throw new PlexusResourceException(
            Status.CLIENT_ERROR_BAD_REQUEST,
            e.getCause(),
            getNexusErrorResponse("search", e.getCause().getMessage()));
      } else {
        throw e;
      }
    }

    throw new ResourceException(
        Status.CLIENT_ERROR_BAD_REQUEST, "Requested search query is not supported");
  }
예제 #26
0
  /**
   * Calls File.listFiles() or File.listFiles(FileFilter) File.listFiles(FilenameFilter) remote
   * method from the client side. <br>
   *
   * @param request the http request
   * @param commonsConfigurator the commons configurator defined by the user
   * @param fileConfigurator the file configurator defined by the user
   * @param out the servlet output stream
   * @param username the client login (for security check)
   * @param filename the filename to call
   * @throws Exception
   */
  public void listFiles(
      HttpServletRequest request,
      CommonsConfigurator commonsConfigurator,
      FileConfigurator fileConfigurator,
      OutputStream out,
      String username,
      String filename)
      throws Exception {

    debug("in listFiles()");

    FileFilter fileFilter = null;
    FilenameFilter filenameFilter = null;

    fileFilter = ServerFilterUtil.buidFileFilter(request, fileConfigurator, username);
    filenameFilter = ServerFilterUtil.buildFilenameFilter(request, fileConfigurator, username);

    debug("After ServerFilterUtil.buidFileFilter");

    filename = HttpConfigurationUtil.addRootPath(fileConfigurator, username, filename);

    File file = new File(filename);
    File[] files = null;

    try {
      if (fileFilter == null && filenameFilter == null) {
        files = file.listFiles();
      } else if (fileFilter != null) {
        files = file.listFiles(fileFilter);
      } else if (filenameFilter != null) {
        files = file.listFiles(filenameFilter);
      } else {
        // Can not happen
        throw new IllegalArgumentException(
            Tag.PRODUCT_PRODUCT_FAIL + " Impossible else condition.");
      }
    } catch (IllegalArgumentException e) {
      // Necessary because Reloader wich extends ClassLoader can nor throw ClassNotFoundException
      if (e.getCause() != null && e.getCause() instanceof ClassNotFoundException) {
        throw new ClassNotFoundException(e.getCause().getMessage());
      }
    }

    if (files == null) {
      writeLine(out, TransferStatus.SEND_OK);
      writeLine(out, null);
      return;
    }

    if (files.length == 0) {
      writeLine(out, TransferStatus.SEND_OK);
      writeLine(out, "[]");
      return;
    }

    writeLine(out, TransferStatus.SEND_OK);

    for (File theFile : files) {
      String fileStr = theFile.toString();

      fileStr = ReturnFileFormatter.format(fileConfigurator, username, fileStr);

      fileStr = HtmlConverter.toHtml(fileStr);
      writeLine(out, fileStr);
    }
  }
예제 #27
0
  public void apply(FaceletContext ctx, UIComponent parent) throws IOException {
    // only process if it's been created
    if (null == parent
        || (null == (parent = parent.getParent()))
        || !(ComponentHandler.isNew(parent))) {
      return;
    }

    Map<String, Object> attrs = parent.getAttributes();

    CompositeComponentBeanInfo componentBeanInfo =
        (CompositeComponentBeanInfo) attrs.get(UIComponent.BEANINFO_KEY);
    assert (null != componentBeanInfo);
    List<PropertyDescriptor> declaredAttributes = componentBeanInfo.getPropertyDescriptorsList();

    // Get the value of required the name propertyDescriptor
    ValueExpression ve = name.getValueExpression(ctx, String.class);
    String strValue = (String) ve.getValue(ctx);

    // Search the propertyDescriptors for one for this attribute
    for (PropertyDescriptor cur : declaredAttributes) {
      if (strValue.endsWith(cur.getName())) {
        // If we have a match, no need to waste time
        // duplicating and replacing it.
        return;
      }
    }

    PropertyDescriptor propertyDescriptor;
    try {
      propertyDescriptor = new CCAttributePropertyDescriptor(strValue, null, null);
      declaredAttributes.add(propertyDescriptor);
    } catch (IntrospectionException ex) {
      throw new TagException(
          tag, "Unable to create property descriptor for property " + strValue, ex);
    }

    TagAttribute defaultTagAttribute = null;
    PropertyHandler defaultHandler = null;
    for (TagAttribute tagAttribute : this.tag.getAttributes().getAll()) {
      String attributeName = tagAttribute.getLocalName();
      if ("default".equals(attributeName)) {
        // store the TagAttribute and the PropertyHandler for later
        // execution, as the handler for the default-attribute requires,
        // that the PropertyHandler for 'type' - if it exists - has been
        // applied first.
        defaultTagAttribute = tagAttribute;
        defaultHandler = ATTRIBUTE_MANAGER.getHandler(ctx, "default");
      } else {
        PropertyHandler handler = ATTRIBUTE_MANAGER.getHandler(ctx, attributeName);
        if (handler != null) {
          handler.apply(ctx, attributeName, propertyDescriptor, tagAttribute);
        }
      }
    }
    if (defaultHandler != null) {
      // If the 'default'-attribute of cc:attribute was set, apply the
      // previously stored PropertyHandler (see above) now, as now it is
      // guaranteed that if a 'type'-attribute existed, that its handler
      // was already applied
      try {
        defaultHandler.apply(ctx, "default", propertyDescriptor, defaultTagAttribute);
      } catch (IllegalArgumentException ex) {
        // If the type (according to the type-attribute) can not be
        // found, the DefaultPropertyHandler will wrapp the
        // ClassNotFoundException into an IllegalArgumentException,
        // which is unwrapped into a TagException here.
        throw new TagException(
            tag, "'type' could not be resolved: " + ex.getCause(), ex.getCause());
      }
    }

    this.nextHandler.apply(ctx, parent);
  }
예제 #28
0
  public void start(
      LockReleaser lockReleaser,
      PersistenceManager persistenceManager,
      RelationshipTypeCreator relTypeCreator,
      Map<Object, Object> params) {
    if (!startIsOk) {
      return;
    }

    String cacheTypeName = (String) params.get(Config.CACHE_TYPE);
    CacheType cacheType = null;
    try {
      cacheType = cacheTypeName != null ? CacheType.valueOf(cacheTypeName) : DEFAULT_CACHE_TYPE;
    } catch (IllegalArgumentException e) {
      throw new IllegalArgumentException(
          "Invalid cache type, please use one of: "
              + Arrays.asList(CacheType.values())
              + " or keep empty for default ("
              + DEFAULT_CACHE_TYPE
              + ")",
          e.getCause());
    }

    if (!readOnly) {
      nodeManager =
          new NodeManager(
              graphDbService,
              cacheManager,
              lockManager,
              lockReleaser,
              transactionManager,
              persistenceManager,
              idGenerator,
              relTypeCreator,
              cacheType);
    } else {
      nodeManager =
          new ReadOnlyNodeManager(
              graphDbService,
              cacheManager,
              lockManager,
              lockReleaser,
              transactionManager,
              persistenceManager,
              idGenerator,
              cacheType);
    }
    // load and verify from PS
    RelationshipTypeData relTypes[] = null;
    PropertyIndexData propertyIndexes[] = null;
    // beginTx();
    relTypes = persistenceManager.loadAllRelationshipTypes();
    propertyIndexes = persistenceManager.loadPropertyIndexes(INDEX_COUNT);
    // commitTx();
    nodeManager.addRawRelationshipTypes(relTypes);
    nodeManager.addPropertyIndexes(propertyIndexes);
    if (propertyIndexes.length < INDEX_COUNT) {
      nodeManager.setHasAllpropertyIndexes(true);
    }
    nodeManager.start(params);
    startIsOk = false;
  }