View Node Management API Reference

Overview

The View Node management system provides comprehensive monitoring and administration capabilities for infrastructure nodes across the View platform. Node objects contain metadata related to ingestion, processing, and persistence nodes within your View deployment, enabling system administrators to monitor, configure, and manage the distributed infrastructure.

Key Features

Infrastructure Monitoring: Monitor the status and health of all View platform nodes
Multi-Service Support: Manage various node types including configuration, processing, storage, and search servers
Cross-Tenant Operations: Nodes provide functionality across multiple tenants without tenant-specific assignment
Startup Tracking: Monitor node startup times and system availability
Administrative Control: Full administrative access for node management and configuration
System Health Monitoring: Track node status and operational metrics

Supported Operations

Enumerate: List all nodes with pagination support
Read: Retrieve individual node configurations and metadata
Read All: Get complete list of all nodes in the system
Delete: Remove node configurations from the system
Existence Check: Verify node presence without retrieving details

API Endpoints

Nodes are managed via the Configuration server API at [http|https]://[hostname]:[port]/v1.0/nodes

Supported HTTP Methods: GET, HEAD, DELETE

Important: All node operations require administrator-level access tokens.

Node Object Structure

Node objects contain comprehensive metadata for infrastructure monitoring and management. Here's the complete structure:

{
    "GUID": "35c21e94-a7f4-4910-855a-d5231a8d7683",
    "Name": "View Lexi Data Catalog",
    "Hostname": "localhost",
    "InstanceType": "LexiServer",
    "LastStartUtc": "2024-10-19T20:06:41.000000Z",
    "CreatedUtc": "2024-07-10T05:11:50.000000Z"
}

Field Descriptions

GUID (GUID): Globally unique identifier for the node object
Name (string): Display name for the node
Hostname (string): Hostname or network address of the node
InstanceType (enum): The instance type of the node (see supported types below)
LastStartUtc (datetime): UTC timestamp from the last startup time of the node
CreatedUtc (datetime): UTC timestamp when the node was created

Supported Instance Types

The InstanceType property can be one of the following:

ConfigServer: Configuration server for system settings and management
DataConnectorServer: Data connector server (crawler) for data ingestion
ProcessorServer: Processing pipeline server for data transformation
LexiServer: Lexi data catalog and search server for metadata management
OrchestratorServer: Data flow orchestration server for workflow management
VectorServer: Vector server for embeddings and similarity search
StorageServer: Storage server for data persistence and retrieval

Enumerate Nodes

Retrieves a paginated list of all node objects in the system using GET /v2.0/nodes. This endpoint provides comprehensive enumeration with pagination support for managing multiple infrastructure nodes.

Request Parameters

No additional parameters required beyond authentication.

{
    "Success": true,
    "Timestamp": {
        "Start": "2024-10-21T02:36:37.677751Z",
        "TotalMs": 23.58,
        "Messages": {}
    },
    "MaxResults": 10,
    "IterationsRequired": 1,
    "EndOfResults": true,
    "RecordsRemaining": 16,
    "Objects": [
        {
            "GUID": "example-node",
            ... node details ...
        },
        { ... }
    ],
    "ContinuationToken": "[continuation-token]"
}

curl --location 'http://view.homedns.org:8000/v2.0/nodes?max-keys=5&token=00000000-0000-0000-0000-000000000000' \
--header 'x-token: *******' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/",//endpoint
  "default", //tenant Id
  "default", //access key
);

api.accessToken = "<adminToken>" //This API requires Admin access

export const enumerateNode = async () => {
  try {
    const nodes = await api.Nodes.enumerate();
    console.log(nodes, "Nodes fetched successfully");
  } catch (err) {
    console.log("Error fetching Nodes:", err);
  }
};
enumerateNode();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def enumerateNodes():
    nodes = configuration.Node.enumerate(headers={"x-token":"<adminToken>"})
    print(nodes)

enumerateNodes()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"),"default", "http://view.homedns.org:8000/"); 
sdk.XToken = "default"
EnumerationResult<Node> response = await sdk.Node.Enumerate();

Response Structure

The enumeration response includes pagination metadata and node objects:

{
    "Success": true,
    "Timestamp": {
        "Start": "2024-10-21T02:36:37.677751Z",
        "TotalMs": 23.58,
        "Messages": {}
    },
    "MaxResults": 10,
    "IterationsRequired": 1,
    "EndOfResults": true,
    "RecordsRemaining": 0,
    "Objects": [
        {
            "GUID": "35c21e94-a7f4-4910-855a-d5231a8d7683",
            "Name": "View Lexi Data Catalog",
            "Hostname": "localhost",
            "InstanceType": "LexiServer",
            "LastStartUtc": "2024-10-19T20:06:41.000000Z",
            "CreatedUtc": "2024-07-10T05:11:50.000000Z"
        }
    ],
    "ContinuationToken": null
}

Read Node

Retrieves node configuration and metadata by GUID using GET /v1.0/nodes/[node-guid]. Returns the complete node configuration including all properties and metadata. If the node doesn't exist, a 404 error is returned.

Request Parameters

node-guid (string, Path, Required): GUID of the node object to retrieve

{
    "GUID": "35c21e94-a7f4-4910-855a-d5231a8d7683",
    "Name": "View Lexi Data Catalog",
    "Hostname": "localhost",
    "InstanceType": "LexiServer",
    "LastStartUtc": "2024-10-19T20:06:41.000000Z",
    "CreatedUtc": "2024-07-10T05:11:50.000000Z"
}

curl --location 'http://view.homedns.org:8000/v1.0/nodes/00000000-0000-0000-0000-000000000000' \
--header 'x-token: *******' \
--header 'Authorization: ••••••'

const { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/",//endpoint
  "default", //tenant Id
  "default" //access key
);

api.accessToken = "<adminToken>" //This API requires Admin access

const getNode = async () => {
  try {
    const nodes = await api.Nodes.read("<nodeId>");
    console.log(nodes, "Nodes fetched successfully");
  } catch (err) {
    console.log("Error fetching Nodes:", err);
  }
};
getNode();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def retrieveNode():
    node = configuration.Node.retrieve("node-guid",headers={"x-token":"<adminToken>"})
    print(node)

retrieveNode()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"),"default", "http://view.homedns.org:8000/"); 
sdk.XToken = "default"
Node response = await sdk.Node.Retrieve(Guid.Parse("node-guid"));

Response

Returns the complete node configuration:

{
    "GUID": "35c21e94-a7f4-4910-855a-d5231a8d7683",
    "Name": "View Lexi Data Catalog",
    "Hostname": "localhost",
    "InstanceType": "LexiServer",
    "LastStartUtc": "2024-10-19T20:06:41.000000Z",
    "CreatedUtc": "2024-07-10T05:11:50.000000Z"
}

Note: the HEAD method can be used as an alternative to get to simply check the existence of the object. HEAD requests return either a 200/OK in the event the object exists, or a 404/Not Found if not. No response body is returned with a HEAD request.

Read All Nodes

Retrieves all node objects in the system using GET /v1.0/nodes/. Returns an array of node objects with complete configuration details for all nodes in the system.

Request Parameters

No additional parameters required beyond authentication.

curl --location 'http://view.homedns.org:8000/v1.0/nodes/' \
--header 'x-token: *******' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

api.accessToken = "<adminToken>" //This API requires Admin access

const getNodes = async () => {
  try {
    const nodes = await api.Nodes.readAll();
    console.log(nodes, "Nodes fetched successfully");
  } catch (err) {
    console.log("Error fetching Nodes:", err);
  }
};
getNodes();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def retrieveAllNodes():
    nodes = configuration.Node.retrieve_all(headers={"x-token":"<adminToken>"})
    print(nodes)    

retrieveAllNodes()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"),"default", "http://view.homedns.org:8000/"); 
sdk.XToken = "default"
List<Node> response = await sdk.Node.RetrieveMany()

Response

Returns an array of all node objects:

[
    {
        "GUID": "35c21e94-a7f4-4910-855a-d5231a8d7683",
        "Name": "View Lexi Data Catalog",
        "Hostname": "localhost",
        "InstanceType": "LexiServer",
        "LastStartUtc": "2024-10-19T20:06:41.000000Z",
        "CreatedUtc": "2024-07-10T05:11:50.000000Z"
    },
    {
        "GUID": "46d32f05-b8g5-5021-966b-e6342b9e8794",
        "Name": "View Configuration Server",
        "Hostname": "localhost",
        "InstanceType": "ConfigServer",
        "LastStartUtc": "2024-10-19T20:05:30.000000Z",
        "CreatedUtc": "2024-07-10T05:11:45.000000Z"
    },
    {
        "GUID": "57e43g16-c9h6-6132-a77c-f7453c0f9805",
        "Name": "View Vector Server",
        "Hostname": "localhost",
        "InstanceType": "VectorServer",
        "LastStartUtc": "2024-10-19T20:07:15.000000Z",
        "CreatedUtc": "2024-07-10T05:11:55.000000Z"
    }
]

Delete Node

Deletes a node object by GUID using DELETE /v1.0/nodes/[node-guid]. This operation permanently removes the node configuration from the system. Use with caution as this action cannot be undone.

Important Note: Deletion of a node configuration does not terminate or shut down the actual node service itself.

Request Parameters

node-guid (string, Path, Required): GUID of the node object to delete

curl --location --request DELETE 'http://view.homedns.org:8000/v1.0/nodes/00000000-0000-0000-0000-000000000000' \
--header 'x-token: *******' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

api.accessToken = "<adminToken>" //This API requires Admin access

const deleteNode = async () => {
  try {
    await api.Nodes.delete("<nodeId>");	
    console.log("Node deleted successfully");
  } catch (err) {
    console.log("Error deleting Node:", err);
  }
};
deleteNode();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def deleteNode():
    node = configuration.Node.delete("node-guid",headers={"x-token":"<adminTokeb>"})
    print(node)

deleteNode()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"),"default", "http://view.homedns.org:8000/");
sdk.XToken = "default"
await sdk.Node.Delete(Guid.Parse("node-guid"));

Response

Returns 204 No Content on successful deletion. No response body is returned.

Check Node Existence

Verifies if a node object exists without retrieving its configuration using HEAD /v1.0/nodes/[node-guid]. This is an efficient way to check node presence before performing operations.

Request Parameters

node-guid (string, Path, Required): GUID of the node object to check

curl --location --head 'http://view.homedns.org:8000/v1.0/nodes/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access Key
);

api.accessToken = "<adminToken>" //This API requires Admin access

export const nodeExists = async () => {
  try {
    const node = await api.Nodes.exists("<node-guid>");
    console.log(node, "Node exists"); //true
  } catch (err) {
    console.log("Error fetching Node:", err);
  }
};

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def checkNode():
    node = configuration.Node.exists("node-guid",headers={"x-token":"<admintoken>"})
    print(node)

checkNode()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("00000000-0000-0000-0000-000000000000"),"default", "http://view.homedns.org:8000/");
sdk.XToken = "default"
bool isExists = await sdk.Node.Exists(Guid.Parse("node-guid"));

Response

200 No Content: Node exists
404 Not Found: Node does not exist
No response body: Only HTTP status code is returned

Note: HEAD requests do not return a response body, only the HTTP status code indicating whether the node exists.

Best Practices

When managing nodes in the View platform, consider the following recommendations for optimal system administration:

Administrator Access: Ensure all node operations use administrator-level authentication tokens
Monitoring Integration: Implement regular node health checks and monitoring systems
Startup Tracking: Monitor LastStartUtc timestamps to track node availability and restarts
Configuration Management: Use node enumeration to maintain accurate infrastructure documentation
System Health: Regularly check node existence and status for system health monitoring