Defining and Enforcing Resource Dependencies in InCa JSON Declarations

[anshulsao]

Enforcing Schema and Dependencies in Resource JSON

Problem Statement

In our Intent-based Catalog Architecture (InCa), we define resources using a JSON format, which includes various fields to describe the resource, its specifications, and potential dependencies on other resources. The challenge arises in ensuring that:

• The JSON adheres to a specific schema, ensuring consistency and reliability in the data provided.
• Dependencies between resources are accurately and reliably defined, considering that some resources might be dependent on others, and these dependencies can be either optional or required.

Example Scenario

Consider a scenario where a resource, such as a Kubernetes node pool, requires another resource - Kubernetes - to be defined as a required dependency. Moreover, since there can be more than one instance of Kubernetes, a mechanism to refer to specific resources in the InCa is crucial.

Suggested Solution

JSON Schema Definition

We propose utilizing JSON Schema to define the structure and validation rules for our resource JSON. This schema will define all necessary fields, their data types, and possible values, ensuring that the resource JSON adheres to the expected format and provides all necessary information.

Dependency Management

In the dependencies section, we introduce two key subsections:

• required: Contains dependencies that must be satisfied for the resource to be valid.
• optional: Contains dependencies that, if present, might alter the behavior or configuration of the resource but are not mandatory.

Each dependency specifies:

• kind: The type or kind of resource upon which there is a dependency.
• resourceRef: A reference to a specific instance of the resource, ensuring the correct resource is identified especially when multiple instances of the same kind exist.

{
  "resourceID": "example_resource",
  "metadata": {
    "name": "ExampleResource",
    "description": "A sample resource in InCa.",
    "maintainer": "[email protected]",
    "documentation_link": "http://example.com/docs",
    "tags": ["example", "sample"]
  },
  "spec": {
    // ... resource specifications ...
  },
  "dependencies": {
    "required": {
      "dep1": {
        "kind": "SpecificKind",
        "resourceRef": "SpecificResourceInstance"
      }
    },
    "optional": {
      "dep2": {
        "kind": "AnotherKind",
        "resourceRef": "AnotherResourceInstance"
      }
    }
  }
}

Validating Data Types and Enforcing Required Dependencies with JSON Schema

Ensuring that the specified dependencies adhere to the expected data types and that required dependencies are indeed provided is crucial for maintaining the integrity of the resource definitions. JSON Schema allows us to enforce these rules by defining the expected data types for each field and marking fields as required when necessary.

Consider a scenario where a "Kubernetes Node Pool" resource must always have a dependency on a "Kubernetes" resource. We can enforce this in the JSON Schema by marking the "Kubernetes" dependency as required in the dependencies section and specifying the expected data type for the kind and resourceRef fields.
Here's a sample schema for the dependencies section of a "Kubernetes Node Pool" resource:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "dependencies": {
      "type": "object",
      "properties": {
        "required": {
          "type": "object",
          "properties": {
            "kubernetes": {
              "type": "object",
              "properties": {
                "kind": {
                  "type": "string",
                  "enum": ["Kubernetes"]
                },
                "resourceRef": {
                  "type": "string"
                }
              },
              "required": ["kind", "resourceRef"]
            }
          },
          "required": ["kubernetes"]
        },
        "optional": {
          "type": "object",
          "additionalProperties": {
            "type": "object",
            "properties": {
              "kind": {
                "type": "string"
              },
              "resourceRef": {
                "type": "string"
              }
            },
            "required": ["kind", "resourceRef"]
          }
        }
      },
      "required": ["required"]
    }
  }
}

[4adway]

Would there be a way to figure out or set a default resource for a certain kind of resource?
For example, if we just leave it at this?
"dep1": {
"kind": "SpecificKind",
}

[rr0hit]

The dependencies discussed here are dependencies between Intent Types. There might be intent to intent dependencies on top of these. Correct?

[rr0hit]

Depending on introducing an apiVersion in discussion 2, it will have to be referred here as well