Java SubjectFactory类代码示例

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
/**
 * Gets all network configuration for a subjectKey.
 *
 * @param subjectClassKey subjectKey class key
 * @param subjectKey      subjectKey key
 * @return 200 OK with network configuration JSON
 */
@GET
@Path("{subjectClassKey}/{subjectKey}")
@Produces(MediaType.APPLICATION_JSON)
@SuppressWarnings("unchecked")
public Response download(@PathParam("subjectClassKey") String subjectClassKey,
                         @PathParam("subjectKey") String subjectKey) {
    NetworkConfigService service = get(NetworkConfigService.class);
    ObjectNode root = mapper().createObjectNode();
    SubjectFactory subjectFactory =
            nullIsNotFound(service.getSubjectFactory(subjectClassKey),
                           subjectClassNotFoundErrorString(subjectClassKey));
    produceSubjectJson(service, root, subjectFactory.createSubject(subjectKey),
                       true,
                       subjectNotFoundErrorString(subjectClassKey, subjectKey));
    return ok(root).build();
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
protected void execute() {
    service = get(NetworkConfigService.class);
    JsonNode root = mapper.createObjectNode();
    if (isNullOrEmpty(subjectClassKey)) {
        addAll((ObjectNode) root);
    } else {
        SubjectFactory subjectFactory = service.getSubjectFactory(subjectClassKey);
        if (isNullOrEmpty(subjectKey)) {
            addSubjectClass((ObjectNode) root, subjectFactory);
        } else {
            Object s = subjectFactory.createSubject(subjectKey);
            if (isNullOrEmpty(configKey)) {
                addSubject((ObjectNode) root, s);
            } else {
                root = getSubjectConfig(getConfig(s, subjectClassKey, configKey));
            }
        }
    }

    try {
        print("%s", mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root));
    } catch (JsonProcessingException e) {
        throw new RuntimeException("Error writing JSON to string", e);
    }
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
protected List<String> choices() {
    NetworkConfigRegistry service = AbstractShellCommand.get(NetworkConfigRegistry.class);
    ArgumentList args = getArgumentList();

    checkArgument(args.getCursorArgumentIndex() >= 2);
    String subjectClassKey = args.getArguments()[args.getCursorArgumentIndex() - 2];

    SubjectFactory<?> subjectFactory = service.getSubjectFactory(subjectClassKey);
    if (subjectFactory == null) {
        return ImmutableList.of();
    }

    String subjectKey = args.getArguments()[args.getCursorArgumentIndex() - 1];

    Object subject = subjectFactory.createSubject(subjectKey);
    Set<? extends Config<Object>> configs = service.getConfigs(subject);
    return configs.stream().map(Config::key).collect(Collectors.toList());
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
/**
 * Upload multiple network configurations for a subject class.
 *
 * @param subjectClassKey subject class key
 * @param request         network configuration JSON rooted at the top node
 * @return 200 OK
 * @throws IOException if unable to parse the request
 */
@POST
@Path("{subjectClassKey}")
@Consumes(MediaType.APPLICATION_JSON)
@SuppressWarnings("unchecked")
public Response upload(@PathParam("subjectClassKey") String subjectClassKey,
                       InputStream request) throws IOException {
    NetworkConfigService service = get(NetworkConfigService.class);
    ObjectNode root = (ObjectNode) mapper().readTree(request);
    SubjectFactory subjectFactory =
            nullIsNotFound(service.getSubjectFactory(subjectClassKey),
                    subjectClassNotValidErrorString(subjectClassKey));
    List<String> errorMsgs = consumeJson(service, root, subjectFactory);
    if (!errorMsgs.isEmpty()) {
        return Response.status(MULTI_STATUS_RESPONE).entity(produceErrorJson(errorMsgs)).build();
    }
    return Response.ok().build();
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void registerConfigFactory(ConfigFactory configFactory) {
    checkNotNull(configFactory, NULL_FACTORY_MSG);
    if (factoryCounters.containsKey(key(configFactory))) {
        factoryCounters.replace(key(configFactory), (factoryCounters.get(key(configFactory)) + 1));
    } else {
        factories.put(key(configFactory), configFactory);
        factoryCounters.put(key(configFactory), 1);

        configClasses.put(identifier(configFactory), configFactory.configClass());

        SubjectFactory subjectFactory = configFactory.subjectFactory();
        subjectClasses.putIfAbsent(subjectFactory.subjectClassKey(), subjectFactory);
        subjectClassKeys.putIfAbsent(subjectFactory.subjectClass(), subjectFactory);

        store.addConfigFactory(configFactory);
    }
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
private List<String> consumeJson(NetworkConfigService service, ObjectNode classNode,
                         SubjectFactory subjectFactory) {
    List<String> errorMsgs = new ArrayList<String>();
    classNode.fieldNames().forEachRemaining(s -> {
        List<String> error = consumeSubjectJson(service, (ObjectNode) classNode.path(s),
                                                subjectFactory.createSubject(s),
                                                subjectFactory.subjectClassKey());
        errorMsgs.addAll(error);
    });
    return errorMsgs;
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
public SubjectFactory getSubjectFactory(Class subjectClass) {
    if (subjectClass == Device.class) {
        return mockDevicesSubjectFactory;
    } else if (subjectClass == Link.class) {
        return mockLinksSubjectFactory;
    }
    return null;
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
protected List<String> choices() {
    NetworkConfigRegistry service = AbstractShellCommand.get(NetworkConfigRegistry.class);
    ArgumentList args = getArgumentList();
    String subjectClassKey = args.getArguments()[args.getCursorArgumentIndex() - 1];

    SubjectFactory subjectFactory = service.getSubjectFactory(subjectClassKey);
    if (subjectFactory == null) {
        return Collections.emptyList();
    }
    // get all registered subject objects.
    Set<Object> subjects = service.getSubjects(subjectFactory.subjectClass());
    return subjects.stream().map(subjectFactory::subjectKey).collect(Collectors.toList());
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void addAll(ObjectNode root) {
    service.getSubjectClasses()
            .forEach(sc -> {
                SubjectFactory sf = service.getSubjectFactory(sc);
                addSubjectClass(newObject(root, sf.subjectClassKey()), sf);
            });
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
protected List<String> choices() {
    NetworkConfigRegistry service = AbstractShellCommand.get(NetworkConfigRegistry.class);
    return service.getSubjectClasses()
            .stream()
            .map(service::getSubjectFactory)
            .map(SubjectFactory::subjectClassKey)
            .collect(Collectors.toList());
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void registerConfigFactory(ConfigFactory configFactory) {
    checkNotNull(configFactory, NULL_FACTORY_MSG);
    factories.put(key(configFactory), configFactory);
    configClasses.put(identifier(configFactory), configFactory.configClass());

    SubjectFactory subjectFactory = configFactory.subjectFactory();
    subjectClasses.putIfAbsent(subjectFactory.subjectClassKey(), subjectFactory);
    subjectClassKeys.putIfAbsent(subjectFactory.subjectClass(), subjectFactory);

    store.addConfigFactory(configFactory);
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
/**
 * Clear all network configurations for a subject class.
 *
 * @param subjectClassKey subject class key
 * @return 204 NO CONTENT
 */
@DELETE
@Path("{subjectClassKey}")
@SuppressWarnings("unchecked")
public Response delete(@PathParam("subjectClassKey") String subjectClassKey) {
    NetworkConfigService service = get(NetworkConfigService.class);
    SubjectFactory subjectFactory =
            nullIsNotFound(service.getSubjectFactory(subjectClassKey),
                    subjectClassNotValidErrorString(subjectClassKey));
    service.getSubjects(subjectFactory.subjectClass())
            .forEach(subject -> service.removeConfig(subject));
    return Response.noContent().build();
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@Override
protected void execute() {
    service = get(NetworkConfigService.class);
    JsonNode root = mapper.createObjectNode();
    if (isNullOrEmpty(subjectClassKey)) {
        if (remove) {
            service.removeConfig();
        }
        addAll((ObjectNode) root);
    } else {
        SubjectFactory subjectFactory = nullIsIllegal(service.getSubjectFactory(subjectClassKey),
                            subjectClassKey + E_CLASSKEY_NOT_REGISTERED);
        if (isNullOrEmpty(subjectKey)) {
            addSubjectClass((ObjectNode) root, subjectFactory);
        } else {
            Object s = subjectFactory.createSubject(subjectKey);
            if (isNullOrEmpty(configKey)) {
                if (remove) {
                    service.removeConfig(s);
                }
                addSubject((ObjectNode) root, s);
            } else {
                if (remove) {
                    service.removeConfig(subjectClassKey, s, configKey);
                }
                root = getSubjectConfig(getConfig(s, subjectClassKey, configKey));
            }
        }
    }

    try {
        print("%s", mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root));
    } catch (JsonProcessingException e) {
        throw new RuntimeException("Error writing JSON to string", e);
    }
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void produceJson(NetworkConfigService service, ObjectNode node,
                         SubjectFactory subjectFactory, Class subjectClass) {
    service.getSubjects(subjectClass).forEach(s ->
        produceSubjectJson(service, newObject(node, subjectFactory.subjectKey(s)), s, false, ""));
}
 

import org.onosproject.net.config.SubjectFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void addSubjectClass(ObjectNode root, SubjectFactory sf) {
    service.getSubjects(sf.subjectClass())
            .forEach(s -> addSubject(newObject(root, sf.subjectKey(s)), s));
}