import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void updateEntityInfo() throws Exception {
    EntityMetadata e = new EntityMetadata("testEntity");
    e.setVersion(new Version("1.0.0", null, "some text blah blah"));
    e.setStatus(MetadataStatus.ACTIVE);
    e.setDataStore(new MongoDataStore(null, null, "testCollection"));
    e.getFields().put(new SimpleField("field1", StringType.TYPE));
    ObjectField o = new ObjectField("field2");
    o.getFields().put(new SimpleField("x", IntegerType.TYPE));
    e.getFields().put(o);

    md.createNewMetadata(e);

    EntityInfo ei = new EntityInfo("testEntity");
    ArrayField af = new ArrayField("arrField", new SimpleArrayElement(StringType.TYPE));
    e.getFields().put(af);
    IndexSortKey isk = new IndexSortKey(new Path("arrField.*"), true, true);
    ei.getIndexes().add(new Index(isk));
    ei.setDataStore(new MongoDataStore(null, null, "somethingelse"));
    md.updateEntityInfo(ei);
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void updateEntityInfo_noEntity() throws Exception {
    EntityMetadata e = new EntityMetadata("testEntity");
    e.setVersion(new Version("1.0.0", null, "some text blah blah"));
    e.setStatus(MetadataStatus.ACTIVE);
    e.setDataStore(new MongoDataStore(null, null, "testCollection"));
    e.getFields().put(new SimpleField("field1", StringType.TYPE));
    ObjectField o = new ObjectField("field2");
    o.getFields().put(new SimpleField("x", IntegerType.TYPE));
    e.getFields().put(o);
    md.createNewMetadata(e);

    EntityInfo ei = new EntityInfo("NottestEntity");
    ei.setDataStore(new MongoDataStore(null, null, "somethingelse"));
    try {
        md.updateEntityInfo(ei);
        Assert.fail();
    } catch (Error ex) {
        Assert.assertEquals(MongoMetadataConstants.ERR_MISSING_ENTITY_INFO, ex.getErrorCode());
    }
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
/**
 * Entry point for entity info parser. Expects an Object corresponding to
 * the EntityInfo object.
 *
 * @throws ParseException
 */
public EntityInfo parseEntityInfo(T object) {
    Error.push("parseEntityInfo");
    try {
        String name = getRequiredStringProperty(object, STR_NAME);

        EntityInfo info = new EntityInfo(name);

        info.setDefaultVersion(getStringProperty(object, STR_DEFAULT_VERSION));
        info.getIndexes().setIndexes(parseArr(getObjectProperty(object, STR_INDEXES), parseIndex));
        info.getEnums().setEnums(parseArr(getObjectProperty(object, STR_ENUMS), parseEnum));
        info.getHooks().setHooks(parseArr(getObjectProperty(object, STR_HOOKS), parseHook));

        T backend = getRequiredObjectProperty(object, STR_DATASTORE);
        info.setDataStore(parseDataStore(backend));
        parseProperties(info, object, ENTITY_INFO_ELEMENTS);

        return info;
    } finally {
        Error.pop();
    }
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void hookTest() throws Exception {
    Extensions<JsonNode> ex = new Extensions<>();
    HookTestCfgParser hookParser = new HookTestCfgParser();
    ex.registerHookConfigurationParser("testHook", hookParser);
    ex.registerDataStoreParser("test", new TestDataStoreParser());
    JsonNode mdJson = json("{'name':'test','datastore':{'backend':'test' }, "
            + "'hooks':[ "
            + "{'name':'testHook','actions':['insert'],"
            + "'projection':{'field':'*','recursive':1},"
            + "'configuration':{'testField':'testValue'} } ] }");
    JSONMetadataParser parser = new JSONMetadataParser(ex, new DefaultTypes(), nodeFactory);
    EntityInfo ei = parser.parseEntityInfo(mdJson);
    Assert.assertNotNull(ei);
    Assert.assertFalse(ei.getHooks().isEmpty());
    Assert.assertEquals("testHook", ei.getHooks().getHooks().get(0).getName());
    Assert.assertTrue(ei.getHooks().getHooks().get(0).isInsert());
    Assert.assertFalse(ei.getHooks().getHooks().get(0).isUpdate());
    Assert.assertFalse(ei.getHooks().getHooks().get(0).isDelete());
    Assert.assertEquals("testValue", ((TestHookCfg) ei.getHooks().getHooks().get(0).getConfiguration()).testName);
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void convertHookTest() throws Exception {
    Extensions<JsonNode> ex = new Extensions<>();
    HookTestCfgParser hookParser = new HookTestCfgParser();
    ex.registerHookConfigurationParser("testHook", hookParser);
    ex.registerDataStoreParser("test", new TestDataStoreParser());

    EntityInfo ei = new EntityInfo("test");
    ArrayList<Hook> hooks = new ArrayList<>();
    Hook hook = new Hook("testHook");
    hook.setInsert(true);
    hook.setProjection(new FieldProjection(new Path("*"), true, true));
    hook.setConfiguration(new TestHookCfg("test"));
    hooks.add(hook);
    ei.getHooks().setHooks(hooks);

    JSONMetadataParser parser = new JSONMetadataParser(ex, new DefaultTypes(), nodeFactory);
    JsonNode node = parser.convert(ei);
    System.out.println(node);
    JSONAssert.assertEquals(node.toString(), json("{'name':'test','datastore':{'backend':'test' }, "
            + "'hooks':[ "
            + "{'name':'testHook','actions':['insert'],"
            + "'projection':{'field':'*','include':true,'recursive':true},"
            + "'configuration':{'testField':'test'} } ] }").toString(), false);

}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
/**
 * Gets or creates the mapped data for the passed in name
 *
 * @param entityName - entity name
 * @param createIfNull - <code>true</code> if a new map should be created
 * and returned, otherwise <code>false</code> and <code>null</code> will be
 * returned.
 * @return the mapped data for the passed in entity name.
 */
private Map<String, Data> getOrCreateVersionedData(String entityName, boolean createIfNull) {
    EntityInfo info = entityInfoMap.get(entityName);
    if (info == null) {
        throw new IllegalStateException("EntityInfo has not yet been set.");
    }

    if (dataMap.get(info) == null) {
        if (createIfNull) {
            dataMap.put(info, new HashMap<String, Data>());
        } else {
            return null;
        }
    }
    return dataMap.get(info);
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void testEntityMetadata() {
    String entityName = "fake";
    String version1 = "1.0.0";
    String version2 = "2.0.0";

    FakeMetadata metadata = new FakeMetadata();

    EntityInfo entityInfo = new EntityInfo(entityName);
    metadata.setEntityInfo(entityInfo);

    assertEquals(entityInfo, metadata.getEntityInfo(entityName));

    EntityMetadata entityMetadata = new EntityMetadata("fake EntityMetadata");
    metadata.setEntityMetadata(entityName, version1, entityMetadata);

    assertEquals(entityMetadata, metadata.getEntityMetadata(entityName, version1));
    assertNull(metadata.getEntityMetadata(entityName, version2));
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void testDependencies() {
    String entityName = "fake";
    String version1 = "1.0.0";
    String version2 = "2.0.0";

    FakeMetadata metadata = new FakeMetadata();

    EntityInfo entityInfo = new EntityInfo(entityName);
    metadata.setEntityInfo(entityInfo);

    assertEquals(entityInfo, metadata.getEntityInfo(entityName));

    Response dependencies = new Response(JsonNodeFactory.instance, OperationStatus.ERROR);
    metadata.setDependencies(entityName, version1, dependencies);

    assertEquals(dependencies, metadata.getDependencies(entityName, version1));
    assertNull(metadata.getDependencies(entityName, version2));
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void testAccess() {
    String entityName = "fake";
    String version1 = "1.0.0";
    String version2 = "2.0.0";

    FakeMetadata metadata = new FakeMetadata();

    EntityInfo entityInfo = new EntityInfo(entityName);
    metadata.setEntityInfo(entityInfo);

    assertEquals(entityInfo, metadata.getEntityInfo(entityName));

    Response access = new Response(JsonNodeFactory.instance, OperationStatus.ERROR);
    metadata.setAccess(entityName, version1, access);

    assertEquals(access, metadata.getAccess(entityName, version1));
    assertNull(metadata.getAccess(entityName, version2));
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
public static void main(String[] args) throws IOException, ClassNotFoundException {
  Cli cli = new Cli(args);

  if (cli.helpRequested()) {
    cli.printHelpTo(System.out);
    System.exit(1);
  }

  ClassLoader classLoader = getClassLoaderToSearch(cli.jarPath());
  Path outputDirectory = cli.outputDirectory()
      .map(Paths::get)
      .orElse(Paths.get("./"));

  if (cli.entityClasses().isEmpty()) {
    println("No entity classes provided.");
    println("");
    cli.printHelpTo(System.out);
    System.exit(1);
  }

  for (String className : cli.entityClasses()) {
    Class classForName = classLoader.loadClass(className);
    EntityInfo info = generator.generateInfo(classForName);

    Path metadataJsonPath = outputDirectory.resolve(info.getName() + ".json")
        .toAbsolutePath();
    EntityMetadata metadata = generateMetadata(classForName, metadataJsonPath);

    JsonNode metadataJson = parser.convert(metadata);

    mapper.writerWithDefaultPrettyPrinter()
        .writeValue(Files.newBufferedWriter(metadataJsonPath, UTF_8), metadataJson);

    println("Wrote " + metadataJsonPath);
  }
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
public EntityMetadata updateMetadata(EntityMetadata original, Class<?> entity) {
  BeanMirror beanMirror = reflector.reflect(entity);

  EntityInfo info = generateInfo(beanMirror, Optional.of(original.getEntityInfo()));
  EntitySchema schema = generateSchema(beanMirror, Optional.of(original.getEntitySchema()));

  return new EntityMetadata(info, schema);
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
public EntityInfo updateInfo(EntityInfo info, Class<?> entity) {
  BeanMirror beanMirror = reflector.reflect(entity);

  if (!Objects.equals(info.getName(), beanMirror.getEntityName())) {
    throw new IllegalArgumentException("Entity name mismatch between provided entity info and "
        + "generated entity info.");
  }

  return generateInfo(beanMirror, Optional.of(info));
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
private EntityInfo generateInfo(BeanMirror beanMirror, Optional<EntityInfo> maybeOriginal) {
  EntityInfo info = new EntityInfo(beanMirror.getEntityName());
  Enums enums = info.getEnums();

  for (FieldMirror fieldMirror : beanMirror.getFields()) {
    if (fieldMirror.javaType().isEnum()) {
      EnumMirror enumMirror = fieldMirror.enumMirror().get();

      Enum generatedEnum = new Enum(enumMirror.name());
      Set<EnumValue> enumValues = new HashSet<>();

      for (EnumValueMirror enumValueMirror : enumMirror.values()) {
        String enumName = enumValueMirror.name();
        String enumDescription = enumValueMirror.description().orElse(null);
        enumValues.add(new EnumValue(enumName, enumDescription));
      }

      generatedEnum.setValues(enumValues);
      enums.addEnum(generatedEnum);
    }
  }

  maybeOriginal.ifPresent(original -> {
    info.getIndexes().setIndexes(original.getIndexes().getIndexes());
    info.getHooks().setHooks(original.getHooks().getHooks());
    info.setDataStore(original.getDataStore());
    info.setDefaultVersion(original.getDefaultVersion());
  });

  return info;
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Override
public String run() {
    try {
        EntityInfo entityInfo = getMetadata().getEntityInfo(entity);
        CRUDController crudController = RestConfiguration.getFactory().getFactory().getCRUDController(entityInfo.getDataStore().getBackend());
        if (crudController instanceof MongoCRUDController) {
            MongoCRUDController mcc = (MongoCRUDController) crudController;
            mcc.reindex(entityInfo, getMetadata(), version, query);
            return String.format("Starting reindex of %s", entity);
        }
        throw new UnsupportedOperationException("This command is only available on MongoDB backed instances");
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
public void reindex(EntityInfo ei, Metadata md, String version, QueryExpression query) throws IOException {
    Map<String, String> fieldMap = DocTranslator.getCaseInsensitiveIndexes(ei.getIndexes().getIndexes()).collect(Collectors.toMap(i -> i.getField().toString(), i -> DocTranslator
            .getHiddenForField(i.getField()).toString()));
    List<Path> fields = DocTranslator.getCaseInsensitiveIndexes(ei.getIndexes().getIndexes()).map(i -> i.getField()).collect(Collectors.toList());
    if (!fieldMap.keySet().isEmpty()) {
        populateHiddenFields(ei, md, version, fields, query);
    }
    // This is not a common command, I think INFO level is safe and appropriate
    LOGGER.info("Starting reindex of {} for fields:  {}", ei.getName(), fieldMap.keySet());
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void testMissingConfiguration() throws IOException, URISyntaxException {
    String jsonString = FileUtil.readFile(getClass().getSimpleName() + "-missing-configuration.json");

    Assert.assertNotNull(jsonString);

    JsonNode node = json(jsonString);

    EntityInfo entityInfo = parser.parseEntityInfo(node);

    // simply won't have configuration on the hook
    Assert.assertFalse(entityInfo.getHooks().isEmpty());
    Assert.assertEquals(AuditHook.HOOK_NAME, entityInfo.getHooks().getHooks().get(0).getName());
    Assert.assertNull(entityInfo.getHooks().getHooks().get(0).getConfiguration());
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Test
public void testValidJson() throws IOException, URISyntaxException {
    String jsonString = FileUtil.readFile(getClass().getSimpleName() + "-valid.json");

    Assert.assertNotNull(jsonString);

    JsonNode node = json(jsonString);

    EntityInfo entityInfo = parser.parseEntityInfo(node);

    Assert.assertNotNull(entityInfo);
    Assert.assertFalse(entityInfo.getHooks().isEmpty());
    Assert.assertEquals(AuditHook.HOOK_NAME, entityInfo.getHooks().getHooks().get(0).getName());
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
protected ConstraintValidator mockEnum(ConstraintValidator validator, Enum e) {
    EntityInfo entityInfo = new EntityInfo("fake name");
    if (e != null) {
        entityInfo.getEnums().addEnum(e);
    }

    EntityMetadata entityMetadata = mock(EntityMetadata.class);
    when(entityMetadata.getEntityInfo()).thenReturn(entityInfo);

    when(validator.getEntityMetadata()).thenReturn(entityMetadata);

    return validator;
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
private synchronized void initializeMetadata(Factory factory) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    if (metadata == null) {
        LOGGER.debug("Initializing metadata");

        JsonNode root = metadataNode;
        if (root == null) {
            try (InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(MetadataConfiguration.FILENAME)) {
                if (null == is) {
                    throw new FileNotFoundException(MetadataConfiguration.FILENAME);
                }
                root = JsonUtils.json(is, true);
            }
        }
        LOGGER.debug("Config root:{}", root);

        JsonNode cfgClass = root.get("type");
        if (cfgClass == null) {
            throw new IllegalStateException(MetadataConstants.ERR_CONFIG_NOT_FOUND + " - type");
        }

        MetadataConfiguration cfg = (MetadataConfiguration) Thread.currentThread().getContextClassLoader().loadClass(
                cfgClass.asText()).newInstance();
        injectDependencies(cfg);

        cfg.initializeFromJson(root);

        // Set validation flag for all metadata requests
        getJsonTranslator().setValidation(EntityMetadata.class, cfg.isValidateRequests());
        getJsonTranslator().setValidation(EntitySchema.class, cfg.isValidateRequests());
        getJsonTranslator().setValidation(EntityInfo.class, cfg.isValidateRequests());

        metadata = cfg.createMetadata(datasources, getJSONParser(), this);

        factory.setHookResolver(new SimpleHookResolver(cfg.getHookConfigurationParsers(), this));
    }
}
 

import com.redhat.lightblue.metadata.EntityInfo; //导入依赖的package包/类
@Override
public void updateEntityInfo(EntityInfo info) {
    if (entityInfoMap.get(info.getName()) == null) {
        throw new IllegalStateException("No EntityInfo currently exists with name: " + info.getName());
    }

    entityInfoMap.put(info.getName(), info);
}