Examples with Port com.google.cloud.aiplatform.v1.Port used on opensource projects

Example 16 with Port

use of com.google.cloud.aiplatform.v1.Port in project java-aiplatform by googleapis.

the class CreateTrainingPipelineTextEntityExtractionSample method createTrainingPipelineTextEntityExtractionSample.

static void createTrainingPipelineTextEntityExtractionSample(String project, String trainingPipelineDisplayName, String datasetId, String modelDisplayName) throws IOException {
    PipelineServiceSettings pipelineServiceSettings = PipelineServiceSettings.newBuilder().setEndpoint("us-central1-aiplatform.googleapis.com:443").build();
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PipelineServiceClient pipelineServiceClient = PipelineServiceClient.create(pipelineServiceSettings)) {
        String location = "us-central1";
        String trainingTaskDefinition = "gs://google-cloud-aiplatform/schema/trainingjob/definition/" + "automl_text_extraction_1.0.0.yaml";
        LocationName locationName = LocationName.of(project, location);
        InputDataConfig trainingInputDataConfig = InputDataConfig.newBuilder().setDatasetId(datasetId).build();
        Model model = Model.newBuilder().setDisplayName(modelDisplayName).build();
        TrainingPipeline trainingPipeline = TrainingPipeline.newBuilder().setDisplayName(trainingPipelineDisplayName).setTrainingTaskDefinition(trainingTaskDefinition).setTrainingTaskInputs(ValueConverter.EMPTY_VALUE).setInputDataConfig(trainingInputDataConfig).setModelToUpload(model).build();
        TrainingPipeline trainingPipelineResponse = pipelineServiceClient.createTrainingPipeline(locationName, trainingPipeline);
        System.out.println("Create Training Pipeline Text Entity Extraction Response");
        System.out.format("\tName: %s\n", trainingPipelineResponse.getName());
        System.out.format("\tDisplay Name: %s\n", trainingPipelineResponse.getDisplayName());
        System.out.format("\tTraining Task Definition %s\n", trainingPipelineResponse.getTrainingTaskDefinition());
        System.out.format("\tTraining Task Inputs: %s\n", trainingPipelineResponse.getTrainingTaskInputs());
        System.out.format("\tTraining Task Metadata: %s\n", trainingPipelineResponse.getTrainingTaskMetadata());
        System.out.format("State: %s\n", trainingPipelineResponse.getState());
        System.out.format("\tCreate Time: %s\n", trainingPipelineResponse.getCreateTime());
        System.out.format("\tStartTime %s\n", trainingPipelineResponse.getStartTime());
        System.out.format("\tEnd Time: %s\n", trainingPipelineResponse.getEndTime());
        System.out.format("\tUpdate Time: %s\n", trainingPipelineResponse.getUpdateTime());
        System.out.format("\tLabels: %s\n", trainingPipelineResponse.getLabelsMap());
        InputDataConfig inputDataConfig = trainingPipelineResponse.getInputDataConfig();
        System.out.println("\tInput Data Config");
        System.out.format("\t\tDataset Id: %s", inputDataConfig.getDatasetId());
        System.out.format("\t\tAnnotations Filter: %s\n", inputDataConfig.getAnnotationsFilter());
        FractionSplit fractionSplit = inputDataConfig.getFractionSplit();
        System.out.println("\t\tFraction Split");
        System.out.format("\t\t\tTraining Fraction: %s\n", fractionSplit.getTrainingFraction());
        System.out.format("\t\t\tValidation Fraction: %s\n", fractionSplit.getValidationFraction());
        System.out.format("\t\t\tTest Fraction: %s\n", fractionSplit.getTestFraction());
        FilterSplit filterSplit = inputDataConfig.getFilterSplit();
        System.out.println("\t\tFilter Split");
        System.out.format("\t\t\tTraining Filter: %s\n", filterSplit.getTrainingFilter());
        System.out.format("\t\t\tValidation Filter: %s\n", filterSplit.getValidationFilter());
        System.out.format("\t\t\tTest Filter: %s\n", filterSplit.getTestFilter());
        PredefinedSplit predefinedSplit = inputDataConfig.getPredefinedSplit();
        System.out.println("\t\tPredefined Split");
        System.out.format("\t\t\tKey: %s\n", predefinedSplit.getKey());
        TimestampSplit timestampSplit = inputDataConfig.getTimestampSplit();
        System.out.println("\t\tTimestamp Split");
        System.out.format("\t\t\tTraining Fraction: %s\n", timestampSplit.getTrainingFraction());
        System.out.format("\t\t\tValidation Fraction: %s\n", timestampSplit.getValidationFraction());
        System.out.format("\t\t\tTest Fraction: %s\n", timestampSplit.getTestFraction());
        System.out.format("\t\t\tKey: %s\n", timestampSplit.getKey());
        Model modelResponse = trainingPipelineResponse.getModelToUpload();
        System.out.println("\tModel To Upload");
        System.out.format("\t\tName: %s\n", modelResponse.getName());
        System.out.format("\t\tDisplay Name: %s\n", modelResponse.getDisplayName());
        System.out.format("\t\tDescription: %s\n", modelResponse.getDescription());
        System.out.format("\t\tMetadata Schema Uri: %s\n", modelResponse.getMetadataSchemaUri());
        System.out.format("\t\tMetadata: %s\n", modelResponse.getMetadata());
        System.out.format("\t\tTraining Pipeline: %s\n", modelResponse.getTrainingPipeline());
        System.out.format("\t\tArtifact Uri: %s\n", modelResponse.getArtifactUri());
        System.out.format("\t\tSupported Deployment Resources Types: %s\n", modelResponse.getSupportedDeploymentResourcesTypesList());
        System.out.format("\t\tSupported Input Storage Formats: %s\n", modelResponse.getSupportedInputStorageFormatsList());
        System.out.format("\t\tSupported Output Storage Formats: %s\n", modelResponse.getSupportedOutputStorageFormatsList());
        System.out.format("\t\tCreate Time: %s\n", modelResponse.getCreateTime());
        System.out.format("\t\tUpdate Time: %s\n", modelResponse.getUpdateTime());
        System.out.format("\t\tLabels: %sn\n", modelResponse.getLabelsMap());
        PredictSchemata predictSchemata = modelResponse.getPredictSchemata();
        System.out.println("\t\tPredict Schemata");
        System.out.format("\t\t\tInstance Schema Uri: %s\n", predictSchemata.getInstanceSchemaUri());
        System.out.format("\t\t\tParameters Schema Uri: %s\n", predictSchemata.getParametersSchemaUri());
        System.out.format("\t\t\tPrediction Schema Uri: %s\n", predictSchemata.getPredictionSchemaUri());
        for (ExportFormat exportFormat : modelResponse.getSupportedExportFormatsList()) {
            System.out.println("\t\tSupported Export Format");
            System.out.format("\t\t\tId: %s\n", exportFormat.getId());
        }
        ModelContainerSpec modelContainerSpec = modelResponse.getContainerSpec();
        System.out.println("\t\tContainer Spec");
        System.out.format("\t\t\tImage Uri: %s\n", modelContainerSpec.getImageUri());
        System.out.format("\t\t\tCommand: %s\n", modelContainerSpec.getCommandList());
        System.out.format("\t\t\tArgs: %s\n", modelContainerSpec.getArgsList());
        System.out.format("\t\t\tPredict Route: %s\n", modelContainerSpec.getPredictRoute());
        System.out.format("\t\t\tHealth Route: %s\n", modelContainerSpec.getHealthRoute());
        for (EnvVar envVar : modelContainerSpec.getEnvList()) {
            System.out.println("\t\t\tEnv");
            System.out.format("\t\t\t\tName: %s\n", envVar.getName());
            System.out.format("\t\t\t\tValue: %s\n", envVar.getValue());
        }
        for (Port port : modelContainerSpec.getPortsList()) {
            System.out.println("\t\t\tPort");
            System.out.format("\t\t\t\tContainer Port: %s\n", port.getContainerPort());
        }
        for (DeployedModelRef deployedModelRef : modelResponse.getDeployedModelsList()) {
            System.out.println("\t\tDeployed Model");
            System.out.format("\t\t\tEndpoint: %s\n", deployedModelRef.getEndpoint());
            System.out.format("\t\t\tDeployed Model Id: %s\n", deployedModelRef.getDeployedModelId());
        }
        Status status = trainingPipelineResponse.getError();
        System.out.println("\tError");
        System.out.format("\t\tCode: %s\n", status.getCode());
        System.out.format("\t\tMessage: %s\n", status.getMessage());
    }
}

Example 17 with Port

use of com.google.cloud.aiplatform.v1.Port in project java-aiplatform by googleapis.

the class CreateTrainingPipelineImageClassificationSample method createTrainingPipelineImageClassificationSample.

static void createTrainingPipelineImageClassificationSample(String project, String trainingPipelineDisplayName, String datasetId, String modelDisplayName) throws IOException {
    PipelineServiceSettings pipelineServiceSettings = PipelineServiceSettings.newBuilder().setEndpoint("us-central1-aiplatform.googleapis.com:443").build();
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PipelineServiceClient pipelineServiceClient = PipelineServiceClient.create(pipelineServiceSettings)) {
        String location = "us-central1";
        String trainingTaskDefinition = "gs://google-cloud-aiplatform/schema/trainingjob/definition/" + "automl_image_classification_1.0.0.yaml";
        LocationName locationName = LocationName.of(project, location);
        AutoMlImageClassificationInputs autoMlImageClassificationInputs = AutoMlImageClassificationInputs.newBuilder().setModelType(ModelType.CLOUD).setMultiLabel(false).setBudgetMilliNodeHours(8000).setDisableEarlyStopping(false).build();
        InputDataConfig trainingInputDataConfig = InputDataConfig.newBuilder().setDatasetId(datasetId).build();
        Model model = Model.newBuilder().setDisplayName(modelDisplayName).build();
        TrainingPipeline trainingPipeline = TrainingPipeline.newBuilder().setDisplayName(trainingPipelineDisplayName).setTrainingTaskDefinition(trainingTaskDefinition).setTrainingTaskInputs(ValueConverter.toValue(autoMlImageClassificationInputs)).setInputDataConfig(trainingInputDataConfig).setModelToUpload(model).build();
        TrainingPipeline trainingPipelineResponse = pipelineServiceClient.createTrainingPipeline(locationName, trainingPipeline);
        System.out.println("Create Training Pipeline Image Classification Response");
        System.out.format("Name: %s\n", trainingPipelineResponse.getName());
        System.out.format("Display Name: %s\n", trainingPipelineResponse.getDisplayName());
        System.out.format("Training Task Definition %s\n", trainingPipelineResponse.getTrainingTaskDefinition());
        System.out.format("Training Task Inputs: %s\n", trainingPipelineResponse.getTrainingTaskInputs());
        System.out.format("Training Task Metadata: %s\n", trainingPipelineResponse.getTrainingTaskMetadata());
        System.out.format("State: %s\n", trainingPipelineResponse.getState());
        System.out.format("Create Time: %s\n", trainingPipelineResponse.getCreateTime());
        System.out.format("StartTime %s\n", trainingPipelineResponse.getStartTime());
        System.out.format("End Time: %s\n", trainingPipelineResponse.getEndTime());
        System.out.format("Update Time: %s\n", trainingPipelineResponse.getUpdateTime());
        System.out.format("Labels: %s\n", trainingPipelineResponse.getLabelsMap());
        InputDataConfig inputDataConfig = trainingPipelineResponse.getInputDataConfig();
        System.out.println("Input Data Config");
        System.out.format("Dataset Id: %s", inputDataConfig.getDatasetId());
        System.out.format("Annotations Filter: %s\n", inputDataConfig.getAnnotationsFilter());
        FractionSplit fractionSplit = inputDataConfig.getFractionSplit();
        System.out.println("Fraction Split");
        System.out.format("Training Fraction: %s\n", fractionSplit.getTrainingFraction());
        System.out.format("Validation Fraction: %s\n", fractionSplit.getValidationFraction());
        System.out.format("Test Fraction: %s\n", fractionSplit.getTestFraction());
        FilterSplit filterSplit = inputDataConfig.getFilterSplit();
        System.out.println("Filter Split");
        System.out.format("Training Filter: %s\n", filterSplit.getTrainingFilter());
        System.out.format("Validation Filter: %s\n", filterSplit.getValidationFilter());
        System.out.format("Test Filter: %s\n", filterSplit.getTestFilter());
        PredefinedSplit predefinedSplit = inputDataConfig.getPredefinedSplit();
        System.out.println("Predefined Split");
        System.out.format("Key: %s\n", predefinedSplit.getKey());
        TimestampSplit timestampSplit = inputDataConfig.getTimestampSplit();
        System.out.println("Timestamp Split");
        System.out.format("Training Fraction: %s\n", timestampSplit.getTrainingFraction());
        System.out.format("Validation Fraction: %s\n", timestampSplit.getValidationFraction());
        System.out.format("Test Fraction: %s\n", timestampSplit.getTestFraction());
        System.out.format("Key: %s\n", timestampSplit.getKey());
        Model modelResponse = trainingPipelineResponse.getModelToUpload();
        System.out.println("Model To Upload");
        System.out.format("Name: %s\n", modelResponse.getName());
        System.out.format("Display Name: %s\n", modelResponse.getDisplayName());
        System.out.format("Description: %s\n", modelResponse.getDescription());
        System.out.format("Metadata Schema Uri: %s\n", modelResponse.getMetadataSchemaUri());
        System.out.format("Metadata: %s\n", modelResponse.getMetadata());
        System.out.format("Training Pipeline: %s\n", modelResponse.getTrainingPipeline());
        System.out.format("Artifact Uri: %s\n", modelResponse.getArtifactUri());
        System.out.format("Supported Deployment Resources Types: %s\n", modelResponse.getSupportedDeploymentResourcesTypesList());
        System.out.format("Supported Input Storage Formats: %s\n", modelResponse.getSupportedInputStorageFormatsList());
        System.out.format("Supported Output Storage Formats: %s\n", modelResponse.getSupportedOutputStorageFormatsList());
        System.out.format("Create Time: %s\n", modelResponse.getCreateTime());
        System.out.format("Update Time: %s\n", modelResponse.getUpdateTime());
        System.out.format("Labels: %sn\n", modelResponse.getLabelsMap());
        PredictSchemata predictSchemata = modelResponse.getPredictSchemata();
        System.out.println("Predict Schemata");
        System.out.format("Instance Schema Uri: %s\n", predictSchemata.getInstanceSchemaUri());
        System.out.format("Parameters Schema Uri: %s\n", predictSchemata.getParametersSchemaUri());
        System.out.format("Prediction Schema Uri: %s\n", predictSchemata.getPredictionSchemaUri());
        for (ExportFormat exportFormat : modelResponse.getSupportedExportFormatsList()) {
            System.out.println("Supported Export Format");
            System.out.format("Id: %s\n", exportFormat.getId());
        }
        ModelContainerSpec modelContainerSpec = modelResponse.getContainerSpec();
        System.out.println("Container Spec");
        System.out.format("Image Uri: %s\n", modelContainerSpec.getImageUri());
        System.out.format("Command: %s\n", modelContainerSpec.getCommandList());
        System.out.format("Args: %s\n", modelContainerSpec.getArgsList());
        System.out.format("Predict Route: %s\n", modelContainerSpec.getPredictRoute());
        System.out.format("Health Route: %s\n", modelContainerSpec.getHealthRoute());
        for (EnvVar envVar : modelContainerSpec.getEnvList()) {
            System.out.println("Env");
            System.out.format("Name: %s\n", envVar.getName());
            System.out.format("Value: %s\n", envVar.getValue());
        }
        for (Port port : modelContainerSpec.getPortsList()) {
            System.out.println("Port");
            System.out.format("Container Port: %s\n", port.getContainerPort());
        }
        for (DeployedModelRef deployedModelRef : modelResponse.getDeployedModelsList()) {
            System.out.println("Deployed Model");
            System.out.format("Endpoint: %s\n", deployedModelRef.getEndpoint());
            System.out.format("Deployed Model Id: %s\n", deployedModelRef.getDeployedModelId());
        }
        Status status = trainingPipelineResponse.getError();
        System.out.println("Error");
        System.out.format("Code: %s\n", status.getCode());
        System.out.format("Message: %s\n", status.getMessage());
    }
}

Example 18 with Port

use of com.google.cloud.aiplatform.v1.Port in project java-aiplatform by googleapis.

the class CreateTrainingPipelineSample method createTrainingPipelineSample.

static void createTrainingPipelineSample(String project, String trainingPipelineDisplayName, String datasetId, String trainingTaskDefinition, String modelDisplayName) throws IOException {
    PipelineServiceSettings pipelineServiceSettings = PipelineServiceSettings.newBuilder().setEndpoint("us-central1-aiplatform.googleapis.com:443").build();
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PipelineServiceClient pipelineServiceClient = PipelineServiceClient.create(pipelineServiceSettings)) {
        String location = "us-central1";
        LocationName locationName = LocationName.of(project, location);
        String jsonString = "{\"multiLabel\": false, \"modelType\": \"CLOUD\", \"budgetMilliNodeHours\": 8000," + " \"disableEarlyStopping\": false}";
        Value.Builder trainingTaskInputs = Value.newBuilder();
        JsonFormat.parser().merge(jsonString, trainingTaskInputs);
        InputDataConfig trainingInputDataConfig = InputDataConfig.newBuilder().setDatasetId(datasetId).build();
        Model model = Model.newBuilder().setDisplayName(modelDisplayName).build();
        TrainingPipeline trainingPipeline = TrainingPipeline.newBuilder().setDisplayName(trainingPipelineDisplayName).setTrainingTaskDefinition(trainingTaskDefinition).setTrainingTaskInputs(trainingTaskInputs).setInputDataConfig(trainingInputDataConfig).setModelToUpload(model).build();
        TrainingPipeline trainingPipelineResponse = pipelineServiceClient.createTrainingPipeline(locationName, trainingPipeline);
        System.out.println("Create Training Pipeline Response");
        System.out.format("Name: %s\n", trainingPipelineResponse.getName());
        System.out.format("Display Name: %s\n", trainingPipelineResponse.getDisplayName());
        System.out.format("Training Task Definition %s\n", trainingPipelineResponse.getTrainingTaskDefinition());
        System.out.format("Training Task Inputs: %s\n", trainingPipelineResponse.getTrainingTaskInputs());
        System.out.format("Training Task Metadata: %s\n", trainingPipelineResponse.getTrainingTaskMetadata());
        System.out.format("State: %s\n", trainingPipelineResponse.getState());
        System.out.format("Create Time: %s\n", trainingPipelineResponse.getCreateTime());
        System.out.format("StartTime %s\n", trainingPipelineResponse.getStartTime());
        System.out.format("End Time: %s\n", trainingPipelineResponse.getEndTime());
        System.out.format("Update Time: %s\n", trainingPipelineResponse.getUpdateTime());
        System.out.format("Labels: %s\n", trainingPipelineResponse.getLabelsMap());
        InputDataConfig inputDataConfig = trainingPipelineResponse.getInputDataConfig();
        System.out.println("Input Data Config");
        System.out.format("Dataset Id: %s", inputDataConfig.getDatasetId());
        System.out.format("Annotations Filter: %s\n", inputDataConfig.getAnnotationsFilter());
        FractionSplit fractionSplit = inputDataConfig.getFractionSplit();
        System.out.println("Fraction Split");
        System.out.format("Training Fraction: %s\n", fractionSplit.getTrainingFraction());
        System.out.format("Validation Fraction: %s\n", fractionSplit.getValidationFraction());
        System.out.format("Test Fraction: %s\n", fractionSplit.getTestFraction());
        FilterSplit filterSplit = inputDataConfig.getFilterSplit();
        System.out.println("Filter Split");
        System.out.format("Training Filter: %s\n", filterSplit.getTrainingFilter());
        System.out.format("Validation Filter: %s\n", filterSplit.getValidationFilter());
        System.out.format("Test Filter: %s\n", filterSplit.getTestFilter());
        PredefinedSplit predefinedSplit = inputDataConfig.getPredefinedSplit();
        System.out.println("Predefined Split");
        System.out.format("Key: %s\n", predefinedSplit.getKey());
        TimestampSplit timestampSplit = inputDataConfig.getTimestampSplit();
        System.out.println("Timestamp Split");
        System.out.format("Training Fraction: %s\n", timestampSplit.getTrainingFraction());
        System.out.format("Validation Fraction: %s\n", timestampSplit.getValidationFraction());
        System.out.format("Test Fraction: %s\n", timestampSplit.getTestFraction());
        System.out.format("Key: %s\n", timestampSplit.getKey());
        Model modelResponse = trainingPipelineResponse.getModelToUpload();
        System.out.println("Model To Upload");
        System.out.format("Name: %s\n", modelResponse.getName());
        System.out.format("Display Name: %s\n", modelResponse.getDisplayName());
        System.out.format("Description: %s\n", modelResponse.getDescription());
        System.out.format("Metadata Schema Uri: %s\n", modelResponse.getMetadataSchemaUri());
        System.out.format("Metadata: %s\n", modelResponse.getMetadata());
        System.out.format("Training Pipeline: %s\n", modelResponse.getTrainingPipeline());
        System.out.format("Artifact Uri: %s\n", modelResponse.getArtifactUri());
        System.out.format("Supported Deployment Resources Types: %s\n", modelResponse.getSupportedDeploymentResourcesTypesList());
        System.out.format("Supported Input Storage Formats: %s\n", modelResponse.getSupportedInputStorageFormatsList());
        System.out.format("Supported Output Storage Formats: %s\n", modelResponse.getSupportedOutputStorageFormatsList());
        System.out.format("Create Time: %s\n", modelResponse.getCreateTime());
        System.out.format("Update Time: %s\n", modelResponse.getUpdateTime());
        System.out.format("Labels: %sn\n", modelResponse.getLabelsMap());
        PredictSchemata predictSchemata = modelResponse.getPredictSchemata();
        System.out.println("Predict Schemata");
        System.out.format("Instance Schema Uri: %s\n", predictSchemata.getInstanceSchemaUri());
        System.out.format("Parameters Schema Uri: %s\n", predictSchemata.getParametersSchemaUri());
        System.out.format("Prediction Schema Uri: %s\n", predictSchemata.getPredictionSchemaUri());
        for (ExportFormat exportFormat : modelResponse.getSupportedExportFormatsList()) {
            System.out.println("Supported Export Format");
            System.out.format("Id: %s\n", exportFormat.getId());
        }
        ModelContainerSpec modelContainerSpec = modelResponse.getContainerSpec();
        System.out.println("Container Spec");
        System.out.format("Image Uri: %s\n", modelContainerSpec.getImageUri());
        System.out.format("Command: %s\n", modelContainerSpec.getCommandList());
        System.out.format("Args: %s\n", modelContainerSpec.getArgsList());
        System.out.format("Predict Route: %s\n", modelContainerSpec.getPredictRoute());
        System.out.format("Health Route: %s\n", modelContainerSpec.getHealthRoute());
        for (EnvVar envVar : modelContainerSpec.getEnvList()) {
            System.out.println("Env");
            System.out.format("Name: %s\n", envVar.getName());
            System.out.format("Value: %s\n", envVar.getValue());
        }
        for (Port port : modelContainerSpec.getPortsList()) {
            System.out.println("Port");
            System.out.format("Container Port: %s\n", port.getContainerPort());
        }
        for (DeployedModelRef deployedModelRef : modelResponse.getDeployedModelsList()) {
            System.out.println("Deployed Model");
            System.out.format("Endpoint: %s\n", deployedModelRef.getEndpoint());
            System.out.format("Deployed Model Id: %s\n", deployedModelRef.getDeployedModelId());
        }
        Status status = trainingPipelineResponse.getError();
        System.out.println("Error");
        System.out.format("Code: %s\n", status.getCode());
        System.out.format("Message: %s\n", status.getMessage());
    }
}

Example 19 with Port

use of com.google.cloud.aiplatform.v1.Port in project flow.service.workflow by boomerang-io.

the class ModelConverterV5 method createPort.

private static Port createPort(String position, String taskId, String type) {
    String uniqueId = generateUniqueID();
    Port port = new Port();
    port.setPosition(position);
    port.setNodePortId(uniqueId);
    port.setId(uniqueId);
    port.setSelected(false);
    port.setParentNode(taskId);
    String[] taskTypeList = { CUSTOMTASKNAME, TEMPLATETASKNAME, "approval", "manual", "setwfstatus", "setwfproperty", "eventwait", "releaselock", TaskType.script.toString(), "acquirelock", "runworkflow", "runscheduledworkflow" };
    if (Arrays.stream(taskTypeList).anyMatch(x -> x.equals(type))) {
        port.setType("task");
    } else {
        port.setType(type);
    }
    List<String> linksList = new LinkedList<>();
    port.setLinks(linksList);
    port.setName(position);
    port.setLinks(linksList);
    return port;
}

Example 20 with Port

use of com.google.cloud.aiplatform.v1.Port in project osate2 by osate.

the class CreateConnectionsSwitch method appendSegment.

/**
 * appendSegment Append a segment to a connection instance.
 *
 * @param newSegment
 *            the declarative connection to be added to the connection
 *            instance
 * @param ci
 *            the component that contains the new segment
 * @param goOpposite
 *            the current declarative connection is bidirectional and we are
 *            following it toward its source
 * @param conni
 *            the connection instance representing the semantic connection
 */
// TODO-LW: set 'complete' in conn info
private void appendSegment(ConnectionInfo connInfo, final Connection newSegment, final ComponentInstance ci, final boolean goOpposite) {
    final boolean didModeTransitionConnection = doModeTransitionConnections(ci, connInfo, newSegment);
    final ConnectionEnd fromEnd = goOpposite ? newSegment.getAllDestination() : newSegment.getAllSource();
    final Context fromCtx = goOpposite ? newSegment.getAllDestinationContext() : newSegment.getAllSourceContext();
    ConnectionEnd toEnd = goOpposite ? newSegment.getAllSource() : newSegment.getAllDestination();
    final Context toCtx = goOpposite ? newSegment.getAllSourceContext() : newSegment.getAllDestinationContext();
    final ComponentInstance toCi = (toCtx instanceof Subcomponent) ? ci.findSubcomponentInstance((Subcomponent) toCtx) : null;
    final boolean finalComponent = isConnectionEndingComponent(toCtx);
    final boolean dstEmpty = toCtx instanceof Subcomponent && toCi.getComponentInstances().isEmpty();
    ConnectionInstanceEnd fromFi = null;
    ConnectionInstanceEnd toFi = null;
    FeatureInstance pushedFeature = null;
    FeatureInstance poppedFeature = null;
    FeatureInstance downedFeature = null;
    /*
		 * FIX JD If we have a data component directly connected to a subprogram
		 * parameter, we do not handle it because we do not deal with parameter
		 * connection within the instance model. See bug #220
		 */
    if ((toEnd instanceof ParameterImpl) && ((fromEnd instanceof DataSubcomponent) || (fromEnd instanceof DataAccess))) {
        return;
    }
    /*
		 * Fix JD bug #222.
		 * Tweaked again for Issue #2162: changed to check if the context is a subprogram call
		 * rather than just checking if the feature is contained in a subprogram.
		 */
    if ((toEnd instanceof DataAccess) && (toCtx instanceof SubprogramCall)) {
        return;
    }
    if (toCtx instanceof Subcomponent && toCi == null) {
        if (!(toCtx instanceof SubprogramSubcomponent)) {
            error(ci, "Instantiation error: no component instance for subcomponent " + toCtx.getName());
        }
        return;
    }
    if (!(fromEnd instanceof Subcomponent)) {
        // fromEnd is a feature
        final ComponentInstance fromCi = (fromCtx instanceof Subcomponent) ? ci.findSubcomponentInstance((Subcomponent) fromCtx) : null;
        if (fromCtx instanceof Subcomponent && fromCi == null) {
            if (!(fromCtx instanceof SubprogramSubcomponent)) {
                error(ci, "Instantiation error: no component instance for subcomponent " + fromCtx.getName());
            }
            return;
        }
        List<FeatureInstance> fiList = null;
        if (fromCtx instanceof FeatureGroup) {
            // TODO phf: find index and compare with stack
            FeatureInstance fgi = (FeatureInstance) AadlUtil.findNamedElementInList(ci.getFeatureInstances(), fromCtx.getName());
            if (fgi != null) {
                fiList = fgi.getFeatureInstances();
                fromFi = (FeatureInstance) AadlUtil.findNamedElementInList(fiList, fromEnd.getName());
            }
            if (fromFi != null) {
                if (!upFeature.empty()) {
                    FeatureInstance popfi = upFeature.peek();
                    // match against stack only if we don't reach deeper into feature group
                    if (connInfo.dstToMatch == null && !Aadl2InstanceUtil.isSame(popfi, (FeatureInstance) fromFi)) {
                        // did not match
                        return;
                    } else {
                        poppedFeature = upFeature.pop();
                    }
                } else {
                    downFeature.push((FeatureInstance) fromFi);
                    downedFeature = (FeatureInstance) fromFi;
                }
            }
        } else {
            fiList = (fromCi != null ? fromCi : ci).getFeatureInstances();
            fromFi = (FeatureInstance) AadlUtil.findNamedElementInList(fiList, fromEnd.getName());
        }
    } else {
        fromFi = ci.findSubcomponentInstance((Subcomponent) fromEnd);
    }
    if (!(toEnd instanceof Subcomponent)) {
        List<FeatureInstance> fiList = null;
        if (toCtx instanceof FeatureGroup) {
            FeatureInstance fgi = (FeatureInstance) AadlUtil.findNamedElementInList(ci.getFeatureInstances(), toCtx.getName());
            if (fgi != null) {
                fiList = fgi.getFeatureInstances();
                toFi = (FeatureInstance) AadlUtil.findNamedElementInList(fiList, toEnd.getName());
            }
            if (toFi != null) {
                upFeature.push((FeatureInstance) toFi);
                pushedFeature = (FeatureInstance) toFi;
            }
        } else {
            fiList = (toCi != null ? toCi : ci).getFeatureInstances();
            toFi = (FeatureInstance) AadlUtil.findNamedElementInList(fiList, toEnd.getName());
        }
    } else {
        toFi = ci.findSubcomponentInstance((Subcomponent) toEnd);
    }
    /*
		 * Issue 2032: We do not want connections that go from abstract subcomponent to the ports of
		 * their containing components if the containing component is final. We specifically are
		 * checking that the connection starts at a port feature and ends at a feature that is a feature
		 * of the containing component and the containing component is a connection ending component. We don't
		 * have to check that the end feature is a port because AADL semantics guarantee that it will be.
		 */
    if (fromFi instanceof FeatureInstance && ((FeatureInstance) fromFi).getFeature() instanceof Port && toFi.eContainer().equals(ci) && isConnectionEndingCategory(ci.getCategory())) {
        return;
    }
    try {
        boolean[] keep = { false };
        boolean valid = connInfo.addSegment(newSegment, fromFi, toFi, ci, goOpposite, keep);
        if (!keep[0]) {
            return;
        }
        if (!valid) {
            if (toFi == null) {
                error(ci, "Connection from " + connInfo.src.getInstanceObjectPath() + " via " + newSegment.getQualifiedName() + " has no valid direction. Connection instance not created.");
            } else {
                error(ci, "Connection from " + connInfo.src.getInstanceObjectPath() + " to " + toFi.getInstanceObjectPath() + " has no valid direction. Connection instance not created.");
            }
            return;
        }
        // first check if the connection must end with the new segment
        if (toEnd instanceof Subcomponent) {
            ComponentInstance toInstance = ci.findSubcomponentInstance((Subcomponent) toEnd);
            if (toInstance == null) {
                // happens if conn leaves system to aggregate data port
                warning(ci, "Connection to " + toEnd.getQualifiedName() + " could not be instantiated.");
            } else {
                // connection ends at a shared data, bus, or subprogram (group)
                connInfo.complete = true;
                finalizeConnectionInstance(ci.getSystemInstance(), connInfo, toInstance);
            }
        } else if (toEnd instanceof InternalFeature || toEnd instanceof ProcessorFeature) {
            // can't handle these
            // FIXME: What if a connection from outside goes to one of these?
            warning(ci, "Connection to " + toEnd.getQualifiedName() + " could not be instantiated.");
        } else {
            Feature toFeature = (Feature) toEnd;
            if (toEnd instanceof Parameter) {
                // connection ends at a parameter
                FeatureInstance dstFi = toCi.findFeatureInstance(toFeature);
                if (dstFi == null) {
                    error(toCi, "Destination feature " + toFeature.getName() + " not found. No connection created.");
                } else {
                    connInfo.complete = true;
                    finalizeConnectionInstance(ci, connInfo, dstFi);
                }
            } else if (dstEmpty) {
                // connection ends because the destination component does not
                // contain any subcomponents
                FeatureInstance dstFi = toCi.findFeatureInstance(toFeature);
                if (dstFi == null) {
                    error(toCi, "Destination feature " + toFeature.getName() + " not found. No connection created.");
                } else {
                    connInfo.complete = true;
                    finalizeConnectionInstance(ci, connInfo, dstFi);
                }
            } else if (!(toCtx instanceof Subcomponent)) {
                // implementation
                if (ci instanceof SystemInstance) {
                    if (toCtx instanceof FeatureGroup) {
                        // XXX: PHF: going up into an element of a feature group
                        // should we go to the FG or to the feature?
                        finalizeConnectionInstance(ci, connInfo, ci.findFeatureInstance((FeatureGroup) toCtx));
                    } else {
                        finalizeConnectionInstance(ci, connInfo, ci.findFeatureInstance(toFeature));
                    }
                } else {
                    if (toCtx instanceof FeatureGroup) {
                        toFeature = (FeatureGroup) toCtx;
                    // toFeature now points to the enclosing feature group
                    // this should be the starting feature for the next
                    // connection
                    }
                    ComponentInstance nextCi = ci.getContainingComponentInstance();
                    List<Connection> parentConns = InstanceUtil.getComponentImplementation(nextCi, 0, classifierCache).getAllConnections();
                    FeatureInstance dstFi = ci.findFeatureInstance(toFeature);
                    List<Connection> conns = filterOutgoingConnections(parentConns, dstFi.getFeature(), ci.getSubcomponent());
                    if (conns.isEmpty()) {
                        if (!didModeTransitionConnection) {
                            if (ci instanceof SystemInstance) {
                                finalizeConnectionInstance(ci, connInfo, ci.findFeatureInstance(toFeature));
                            } else {
                                warning(toFi, "Could not continue connection from " + connInfo.src.getInstanceObjectPath() + "  through " + toFi.getInstanceObjectPath() + ". No connection instance created.");
                            }
                        }
                    } else {
                        for (Connection nextConn : conns) {
                            // note: nextConn goes either up or across
                            final ConnectionInfo clone = connInfo.cloneInfo();
                            boolean opposite = false;
                            if (nextConn.isAllBidirectional()) {
                                /*
									 * The next connection is bidirectional, but we need to figure out if we are
									 * traveling from its src to dest or from its dest to src.
									 *
									 * Put another way, we traverse the next connection in the opposite direction
									 * only if the destination feature instance of the next connection is equal to
									 * the destination feature instance of the current connection (based on "toFeature" which
									 * already takes it's own opposite direction into account via "goOpposite" at
									 * the start of the method).
									 */
                                final ConnectionEnd nextConnDest = nextConn.getAllDestination();
                                if (nextConnDest instanceof Feature) {
                                    final Feature nextConnDstFeature = (Feature) nextConnDest;
                                    FeatureInstance nextConnDstFi = nextCi.findFeatureInstance(nextConnDstFeature);
                                    /*
										 * If we find the connection destination in the containing component instance, then
										 * the connection is a normal (not reversed) traversal of the connection. The
										 * value of `opposite` will stay `false`.
										 */
                                    if (nextConnDstFi == null) {
                                        /*
											 * Didn't find the next destination in the containing component, so the question
											 * still is, is the destination in a sibling subcomponent or is it a reversed
											 * traversal from the containing component, or even a reversed traversal from
											 * a sibling subcomponent?
											 */
                                        // next goes across, maybe?
                                        Context nextConnDstCtx = nextConn.getAllDestinationContext();
                                        if (nextConnDstCtx instanceof Subcomponent) {
                                            final ComponentInstance nextConnDstSubi = nextCi.findSubcomponentInstance((Subcomponent) nextConnDstCtx);
                                            nextConnDstFi = nextConnDstSubi.findFeatureInstance(nextConnDstFeature);
                                        }
                                        if (nextConnDstFi != null) {
                                            /*
												 * Opposite is true if the dest of the next connection the same feature instance as the
												 * dest of the current connection.
												 */
                                            opposite = ci.findFeatureInstance(toFeature) == nextConnDstFi;
                                        }
                                    }
                                }
                            } else {
                            /*
									 * not bidirectional, so the src of nextConn is a feature of 'ci', and the dest
									 * is a feature of either 'nextCi` or a sibling subcomponent. We are following
									 * the connection in its natural direction, so `opposite` is `false`.
									 */
                            }
                            appendSegment(clone, nextConn, nextCi, opposite);
                        }
                    }
                }
            } else {
                if (toCtx instanceof Subcomponent && toCi == null) {
                    if (!(toCtx instanceof SubprogramSubcomponent)) {
                        error(ci, "Instantiation error: no component instance for subcomponent " + toCtx.getName());
                    }
                    return;
                }
                toFi = toCi.findFeatureInstance(toFeature);
                if (toFi == null) {
                    error(ci, "Could not find instance object for feature " + toEnd.getName() + " of subcomponent " + ((Subcomponent) toCtx).getName() + ". No connection instance created.");
                    return;
                }
                ComponentImplementation toImpl = InstanceUtil.getComponentImplementation(toCi, 0, classifierCache);
                if (toImpl == null) {
                    connInfo.complete = true;
                    finalizeConnectionInstance(ci, connInfo, toFi);
                } else {
                    // there is a toImpl
                    /*
						 * Issue 2032: Get the connections internal to the destination component that connect
						 * to the feature. Two cases here. (1) If the component is final (thread/device/processor),
						 * we only follow access features inside, (2) otherwise we follow all the internal connections
						 * except for the parameter connections. We keep track of whether any internal connections were
						 * ignored so we know if we should create a connection instance that stops at the component itself.
						 */
                    final AtomicBoolean hasIgnoredConnection = new AtomicBoolean(false);
                    List<Connection> conns = AadlUtil.getIngoingConnections(toImpl, toFeature, c -> {
                        if (c instanceof AccessConnection) {
                            // never ignore access connections
                            return true;
                        } else if (c instanceof ParameterConnection) {
                            // always ignore parameter connections
                            hasIgnoredConnection.set(true);
                            return false;
                        } else {
                            // Ignore other connections only if the component is connection ending
                            if (finalComponent) {
                                hasIgnoredConnection.set(true);
                                return false;
                            } else {
                                return true;
                            }
                        }
                    });
                    if (conns.isEmpty()) {
                        // No internal connections, or they are all parameter connections, so we stop here
                        List<Subcomponent> subs = toImpl.getAllSubcomponents();
                        if (!subs.isEmpty()) {
                            if (!finalComponent) {
                                warning(ci, "No connection declaration from feature " + toEnd.getName() + " of component " + ((Subcomponent) toCtx).getName() + " to subcomponents. Connection instance ends at " + ((Subcomponent) toCtx).getName());
                            }
                            connInfo.complete = true;
                            finalizeConnectionInstance(ci, connInfo, toFi);
                        }
                    } else {
                        /*
							 * Issue 2032: If we get here then destination component has internal connections,
							 * not all of which are parameter connections. We definitely are going to proceed
							 * inside the component with the connection. However, if there are internal
							 * connections that were ignored, we also need to create a connection instance that
							 * ends at the component.
							 *
							 * NB. Not possible to have an ignored parameter connection from a feature and have a
							 * another not ignored connection from that feature because the only place a
							 * parameter connection can exist is in a subprogram or a thread, and it's
							 * not possible to have a regular port connections internal to
							 * either one of those (with the exception of abstract components, but those
							 * should probably be illegal anyway and we ignore those too).
							 */
                        if (hasIgnoredConnection.get()) {
                            final ConnectionInfo clone = connInfo.cloneInfo();
                            clone.complete = true;
                            finalizeConnectionInstance(ci, clone, toFi);
                        }
                        // as End or as Cxt
                        for (Connection nextConn : conns) {
                            final ConnectionInfo clone = connInfo.cloneInfo();
                            EList<Feature> toflist = toFeature.getAllFeatureRefinements();
                            Context dstCtx = nextConn.getAllDestinationContext();
                            // dstCtx is null if we're going down and in opposite direction
                            final boolean opposite = toflist.contains(nextConn.getAllDestination()) && (dstCtx == null || toCtx == dstCtx) || toflist.contains(dstCtx);
                            appendSegment(clone, nextConn, toCi, opposite);
                        }
                    }
                }
            }
        }
    } finally {
        if (pushedFeature != null) {
            if (!upFeature.empty()) {
                upFeature.pop();
            } else {
                warning(ci, "Popping from empty upindex");
            }
        }
        if (poppedFeature != null) {
            if (downFeature.empty()) {
                upFeature.push(poppedFeature);
            } else {
                // remove from downIndex
                warning(ci, "Trying to push back on while downIndex is not empty");
            }
        }
        if (downedFeature != null) {
            // remove from downIndex
            FeatureInstance popfeature = downFeature.pop();
            if (!Aadl2InstanceUtil.isSame(popfeature, downedFeature)) {
                // should be the same
                warning(ci, "Did not match popped downIndex");
            }
        }
    }
}