Examples with ModelType org.jboss.hal.dmr.ModelType used on opensource projects

Example 6 with ModelType

use of org.jboss.hal.dmr.ModelType in project console by hal.

the class ManagementOperationsPresenter method reload.

@Override
protected void reload() {
    if (environment.isStandalone()) {
        ResourceAddress addressFindNP = MANAGEMENT_OPERATIONS_TEMPLATE.resolve(statementContext);
        Operation operationFindNP = new Operation.Builder(addressFindNP, FIND_NON_PROGRESSING_OPERATION).build();
        ResourceAddress addressMO = MANAGEMENT_OPERATIONS_TEMPLATE.resolve(statementContext);
        Operation operationMO = new Operation.Builder(addressMO, READ_CHILDREN_RESOURCES_OPERATION).param(CHILD_TYPE, ACTIVE_OPERATION).build();
        dispatcher.execute(new Composite(operationFindNP, operationMO), (CompositeResult result) -> {
            ModelNode resultNP = result.step(0).get(RESULT);
            ModelNode resultOperations = result.step(1).get(RESULT);
            final String nonProgressingId = resultNP.isDefined() ? resultNP.asString() : null;
            List<ManagementOperations> activeOps = asNamedNodes(resultOperations.asPropertyList()).stream().map(ManagementOperations::new).peek(activeOp -> {
                if (nonProgressingId != null && nonProgressingId.equals(activeOp.getName())) {
                    activeOp.setAsNonProgressing();
                }
            }).collect(toList());
            getView().update(activeOps);
        });
    } else {
        // return available hosts, to later call a find-non-progressing-operation on each host
        Task<FlowContext> hostsTask = context -> {
            ResourceAddress address = new ResourceAddress();
            Operation operation = new Operation.Builder(address, READ_CHILDREN_NAMES_OPERATION).param(CHILD_TYPE, HOST).build();
            return dispatcher.execute(operation).doOnSuccess(result -> {
                List<String> hosts = result.asList().stream().map(ModelNode::asString).collect(toList());
                context.set(HOSTS, hosts);
            }).toCompletable();
        };
        // return running servers, to later call a find-non-progressing-operation on each runtime server
        Task<FlowContext> serversTask = context -> {
            // /host=*/server=*:query(select=[host,name],where={server-state=running})
            ResourceAddress address = new ResourceAddress().add(HOST, WILDCARD).add(SERVER, WILDCARD);
            Operation operation = new Operation.Builder(address, QUERY).param(SELECT, new ModelNode().add(HOST).add(NAME)).param(WHERE, new ModelNode().set(SERVER_STATE, "running")).build();
            return dispatcher.execute(operation).doOnSuccess(result -> {
                List<String> servers = Collections.emptyList();
                if (result != null && result.isDefined()) {
                    servers = result.asList().stream().map(r -> hostServerAddress(r.get(RESULT))).collect(toList());
                }
                context.set("servers", servers);
            }).toCompletable();
        };
        // call find-non-progressing-operation and read-resource of active operations
        // on each host and server
        Task<FlowContext> findNonProgressingTask = context -> {
            List<String> hosts = context.get(HOSTS);
            List<String> servers = context.get("servers");
            Composite composite = new Composite();
            for (String host : hosts) {
                ResourceAddress address = new ResourceAddress().add(HOST, host).add(CORE_SERVICE, MANAGEMENT).add(SERVICE, MANAGEMENT_OPERATIONS);
                Operation operation = new Operation.Builder(address, FIND_NON_PROGRESSING_OPERATION).build();
                composite.add(operation);
                ResourceAddress ad = new ResourceAddress(address.clone()).add(ACTIVE_OPERATION, WILDCARD);
                Operation operationMO = new Operation.Builder(ad, READ_RESOURCE_OPERATION).build();
                composite.add(operationMO);
            }
            if (!servers.isEmpty()) {
                for (String server : servers) {
                    ResourceAddress address = AddressTemplate.of(server).append(MANAGEMENT_OPERATIONS_TEMPLATE).resolve(statementContext);
                    Operation findOp = new Operation.Builder(address, FIND_NON_PROGRESSING_OPERATION).build();
                    composite.add(findOp);
                    ResourceAddress ad = new ResourceAddress(address.clone()).add(ACTIVE_OPERATION, WILDCARD);
                    Operation operation = new Operation.Builder(ad, READ_RESOURCE_OPERATION).build();
                    composite.add(operation);
                }
            }
            return dispatcher.execute(composite).doOnSuccess(response -> {
                List<String> nonProgressingOps = new ArrayList<>();
                List<ManagementOperations> ops = new ArrayList<>();
                for (ModelNode r : response) {
                    ModelNode result = r.get(RESULT);
                    if (result != null && result.isDefined()) {
                        ModelType type = result.getType();
                        // if model is LIST it is the list of active operations
                        if (ModelType.LIST.equals(type)) {
                            for (ModelNode op : result.asList()) {
                                ModelNode opResult = op.get(RESULT);
                                // the result has two addresses
                                // 1) the active-operation address itself, example
                                // /host=master/server=server-three/core-service=management/service=management-operations/active-operation=1940701884
                                // 2) the resource address
                                // /host=master/server=server-three/subsystem=elytron/filesystem-realm=file1
                                // the active-operation address should be store to later use it to cancel, if needed
                                // the resource address is displayed to the user
                                ModelNode activeOpAddress = op.get(ADDRESS);
                                opResult.get(HAL_ACTIVE_OP_ADDRESS).set(activeOpAddress);
                                String opId = null;
                                List<Property> activeOperationAddressList = activeOpAddress.asPropertyList();
                                for (Property p : activeOperationAddressList) {
                                    if (p.getName().equals(ACTIVE_OPERATION)) {
                                        opId = p.getValue().asString();
                                    }
                                    // store the host and server to later show in the view
                                    if (p.getName().equals(HOST)) {
                                        opResult.get(HAL_ACTIVE_ADDRESS_HOST).set(p.getValue().asString());
                                    }
                                    if (p.getName().equals(SERVER)) {
                                        opResult.get(HAL_ACTIVE_ADDRESS_SERVER).set(p.getValue().asString());
                                    }
                                }
                                NamedNode node = new NamedNode(opId, opResult);
                                ManagementOperations activeOp = new ManagementOperations(node);
                                ops.add(activeOp);
                            }
                        } else {
                            nonProgressingOps.add(result.asString());
                        }
                    }
                }
                // if there are non progressing operations, mark them in the list
                if (!nonProgressingOps.isEmpty()) {
                    Collections.sort(nonProgressingOps);
                    for (ManagementOperations mop : ops) {
                        if (nonProgressingOps.indexOf(mop.getName()) > -1) {
                            mop.setAsNonProgressing();
                        }
                    }
                }
                context.set("active-operations", ops);
            }).toCompletable();
        };
        series(new FlowContext(progress.get()), hostsTask, serversTask, findNonProgressingTask).subscribe(new Outcome<FlowContext>() {

            @Override
            public void onError(FlowContext context, Throwable error) {
                MessageEvent.fire(getEventBus(), Message.error(SafeHtmlUtils.fromString("Error loading management operations: " + error.getMessage())));
            }

            @Override
            public void onSuccess(FlowContext context) {
                List<ManagementOperations> ops = context.get("active-operations");
                getView().update(ops);
            }
        });
    }
}

Example 7 with ModelType

use of org.jboss.hal.dmr.ModelType in project console by hal.

the class ResourceDescription method isDefaultValue.

@JsIgnore
public boolean isDefaultValue(String path, String name, Object value) {
    Property property = findAttribute(path, name);
    if (property != null) {
        ModelNode attribute = property.getValue();
        if (attribute.hasDefined(DEFAULT)) {
            if (value == null) {
                return true;
            } else {
                ModelType type = attribute.get(TYPE).asType();
                if (type.equals(ModelType.INT)) {
                    type = ModelType.LONG;
                }
                Object defaultValue = attribute.get(DEFAULT).as(type);
                return value.equals(defaultValue);
            }
        }
    }
    return false;
}

Example 8 with ModelType

use of org.jboss.hal.dmr.ModelType in project console by hal.

the class Json method anyValue.

private static ModelNode anyValue(String jsonName, String dmrName, ModelNode attributeDescription, Any value) {
    ModelNode node = new ModelNode();
    ModelType type = attributeDescription.get(TYPE).asType();
    switch(type) {
        case BOOLEAN:
            node.set(value.asBoolean());
            break;
        case BIG_INTEGER:
        case INT:
        case LONG:
            long longValue = value.asLong();
            if (type == BIG_INTEGER) {
                node.set(BigInteger.valueOf(longValue));
            } else if (type == INT) {
                node.set((int) longValue);
            } else {
                node.set(longValue);
            }
            break;
        case DOUBLE:
            double doubleValue = value.asDouble();
            node.set(doubleValue);
            break;
        case LIST:
            Any[] array = value.asArray();
            for (Any any : array) {
                node.add(String.valueOf(any));
            }
            break;
        case OBJECT:
            boolean stringValueType = attributeDescription.get(VALUE_TYPE).getType().equals(ModelType.TYPE) && attributeDescription.get(VALUE_TYPE).asType().equals(ModelType.STRING);
            if (stringValueType) {
                JsPropertyMap<Object> map = value.asPropertyMap();
                map.forEach(key -> node.get(key).set(String.valueOf(map.getAny(key))));
            }
            break;
        case STRING:
            node.set(value.asString());
            break;
        // unsupported types
        case BIG_DECIMAL:
        case BYTES:
        case EXPRESSION:
        case PROPERTY:
        case TYPE:
        case UNDEFINED:
            logger.warn("Unsupported type {} when mapping JSON key {} to DMR attribute {}", type, jsonName, dmrName);
            break;
        default:
            break;
    }
    return node;
}

Example 9 with ModelType

use of org.jboss.hal.dmr.ModelType in project console by hal.

the class OperationFactory method asValueNode.

@SuppressWarnings("rawtypes")
private ModelNode asValueNode(String name, Object value, ResourceDescription resourceDescription) {
    ModelNode valueNode = new ModelNode();
    Property attribute = resourceDescription.findAttribute(ATTRIBUTES, name);
    if (attribute != null) {
        String stringValue = String.valueOf(value);
        ModelNode attributeDescription = attribute.getValue();
        ModelType type = attributeDescription.get(TYPE).asType();
        if (attributeDescription.hasDefined(EXPRESSIONS_ALLOWED) && attributeDescription.get(EXPRESSIONS_ALLOWED).asBoolean() && Expression.isExpression(stringValue) && type != ModelType.LIST) {
            valueNode.setExpression(stringValue);
        } else {
            try {
                switch(type) {
                    case BIG_DECIMAL:
                        valueNode.set(BigDecimal.valueOf(Double.parseDouble(stringValue)));
                        break;
                    case BIG_INTEGER:
                        valueNode.set(BigInteger.valueOf(Long.parseLong(stringValue)));
                        break;
                    case BOOLEAN:
                        valueNode.set(Boolean.parseBoolean(stringValue));
                        break;
                    case BYTES:
                        valueNode.set((byte[]) value);
                        break;
                    case DOUBLE:
                        valueNode.set(Double.parseDouble(stringValue));
                        break;
                    case EXPRESSION:
                        valueNode.setExpression(stringValue);
                        break;
                    case INT:
                        valueNode.set(Long.valueOf(stringValue).intValue());
                        break;
                    case LIST:
                        {
                            ModelNode valueTypeNode = attributeDescription.get(VALUE_TYPE);
                            ModelType typeOfValueType = valueTypeNode.getType();
                            if (typeOfValueType == ModelType.TYPE) {
                                ModelType valueType = attributeDescription.get(VALUE_TYPE).asType();
                                if (valueType == ModelType.STRING) {
                                    valueNode.clear();
                                    List l = (List) value;
                                    for (Object o : l) {
                                        valueNode.add(String.valueOf(o));
                                    }
                                } else {
                                    logger.error("Unsupported value type {} for attribute {} of type {}", valueType, name, type);
                                }
                            } else if (typeOfValueType == ModelType.OBJECT) {
                                valueNode = (ModelNode) value;
                            } else {
                                logger.error("Unsupported value type for attribute {} of type {}", name, type);
                            }
                            break;
                        }
                    case LONG:
                        valueNode.set(Long.parseLong(stringValue));
                        break;
                    case OBJECT:
                        ModelNode valueTypeNode = attributeDescription.get(VALUE_TYPE);
                        ModelType typeOfValueType = valueTypeNode.getType();
                        if (typeOfValueType == ModelType.TYPE) {
                            ModelType valueType = attributeDescription.get(VALUE_TYPE).asType();
                            if (valueType == ModelType.STRING) {
                                valueNode.clear();
                                Map map = (Map) value;
                                for (Object k : map.keySet()) {
                                    valueNode.get(String.valueOf(k)).set(String.valueOf(map.get(k)));
                                }
                            } else {
                                valueNode = (ModelNode) value;
                                logger.warn("Unsupported value type {} for attribute {} of type {}. Will try to save anyway.", valueType, name, type);
                            }
                        } else if (typeOfValueType == ModelType.OBJECT) {
                            valueNode = (ModelNode) value;
                        } else {
                            logger.error("Unsupported value type for attribute {} of type {}", name, type);
                        }
                        break;
                    case STRING:
                        valueNode.set(stringValue);
                        break;
                    case PROPERTY:
                    case TYPE:
                    case UNDEFINED:
                        valueNode = null;
                        logger.error("Unsupported type {} for attribute {}", type, name);
                        break;
                    default:
                        break;
                }
            } catch (ClassCastException ignored) {
                logger.error("Unable to cast attribute {} as {}", name, type);
            }
        }
    } else {
        Class<?> clazz = value.getClass();
        logger.warn("Unable to get type information for attribute {}. Will use its class instead ({})", name, clazz);
        try {
            if (String.class == clazz) {
                String stringValue = (String) value;
                if (Expression.isExpression(stringValue)) {
                    valueNode.setExpression(stringValue);
                } else {
                    valueNode.set(stringValue);
                }
            } else if (Boolean.class == clazz) {
                valueNode.set((Boolean) value);
            } else if (Integer.class == clazz) {
                valueNode.set((Integer) value);
            } else if (Double.class == clazz) {
                valueNode.set((Double) value);
            } else if (Long.class == clazz) {
                valueNode.set((Long) value);
            } else if (Float.class == clazz) {
                valueNode.set((Float) value);
            } else if (ArrayList.class == clazz) {
                valueNode.clear();
                List l = (List) value;
                for (Object o : l) {
                    valueNode.add(String.valueOf(o));
                }
            } else if (HashMap.class == clazz) {
                valueNode.clear();
                Map map = (Map) value;
                for (Object k : map.keySet()) {
                    valueNode.get(String.valueOf(k)).set(String.valueOf(map.get(k)));
                }
            } else if (ModelNode.class == clazz) {
                valueNode.set((ModelNode) value);
            } else {
                valueNode = null;
                logger.error("Unsupported class {} for attribute {}", clazz, name);
            }
        } catch (ClassCastException ignored) {
            logger.error("Unable to cast attribute {} as {}", name, clazz);
        }
    }
    return valueNode;
}