@terasky/backstage-plugin-vcf-automation 0.0.1

package/README.md

@@ -0,0 +1,257 @@
+# vcf-automation
+
+Welcome to the vcf-automation plugin!
+
+[![npm latest version](https://img.shields.io/npm/v/@terasky/backstage-plugin-vcf-automation/latest.svg)](https://www.npmjs.com/package/@terasky/backstage-plugin-vcf-automation)
+
+## Description
+
+The `vcf-automation` plugin for Backstage provides visibility into VCF deployments, resources, and projects. It offers detailed views of deployment operations, resource states, and project configurations. The plugin integrates with Backstage's permission framework to ensure secure access control.
+
+## Prerequisites
+
+Before installing this plugin, ensure you have:
+
+1. [VCF Automation Backend Plugin](../vcf-automation-backend/README.md) - Required for API integration
+2. [VCF Ingestor Plugin](../vcf-ingestor/README.md) - Required for entity synchronization
+
+## Installation
+
+### 1. Install the Plugin
+
+Add the plugin to your Backstage project:
+
+```bash
+# From your Backstage root directory
+yarn --cwd packages/app add @terasky/backstage-plugin-vcf-automation
+```
+
+### 2. Register the Plugin
+
+Add the plugin to your app's APIs in `packages/app/src/apis.ts`:
+
+```typescript
+import {
+  vcfAutomationApiRef,
+  VcfAutomationClient,
+} from '@terasky/backstage-plugin-vcf-automation';
+
+export const apis: AnyApiFactory[] = [
+  // ... other API factories
+  createApiFactory({
+    api: vcfAutomationApiRef,
+    deps: { discoveryApi: discoveryApiRef, identityApi: identityApiRef },
+    factory: ({ discoveryApi, identityApi }) => 
+      new VcfAutomationClient({ discoveryApi, identityApi }),
+  }),
+];
+```
+### 3. Add to your App.tsx file
+
+```typescript
+import { vcfAutomationPlugin } from '@terasky/backstage-plugin-vcf-automation';
+
+const app = createApp({
+  apis,
+  bindRoutes({ bind }) {
+    
+    ...
+
+    bind(vcfAutomationPlugin.externalRoutes, {
+      catalogIndex: catalogPlugin.routes.catalogIndex,
+    });
+    
+    ...
+    
+  },
+
+```
+### 4. Add Components to Entity Pages
+
+Add the VCF Automation components to your entity pages in `packages/app/src/components/catalog/EntityPage.tsx`:
+
+```typescript
+import {
+  VCFAutomationDeploymentOverview,
+  VCFAutomationDeploymentDetails,
+  VCFAutomationVSphereVMOverview,
+  VCFAutomationVSphereVMDetails,
+  VCFAutomationGenericResourceOverview,
+  VCFAutomationGenericResourceDetails,
+  VCFAutomationProjectOverview,
+  VCFAutomationProjectDetails,
+} from '@terasky/backstage-plugin-vcf-automation';
+import { Entity } from '@backstage/catalog-model';
+
+// For VSphere VMs
+const vcfAutomationVSphereVMPage = (
+  <EntityLayout>
+    <EntityLayout.Route path="/" title="Overview">
+      <Grid container spacing={3} alignItems="stretch">
+        <Grid item md={6}>
+          <EntityAboutCard variant="gridItem" />
+        </Grid>
+        <Grid item md={6}>
+          <VCFAutomationVSphereVMOverview />
+        </Grid>
+      </Grid>
+    </EntityLayout.Route>
+    <EntityLayout.Route path="/vcf-automation" title="VCF Automation">
+      <VCFAutomationVSphereVMDetails />
+    </EntityLayout.Route>
+  </EntityLayout>
+);
+
+// Add to your component page switch
+const componentPage = (
+  <EntitySwitch>
+    <EntitySwitch.Case if={isComponentType('Cloud.vSphere.Machine')}>
+      {vcfAutomationVSphereVMPage}
+    </EntitySwitch.Case>
+    // ... other cases
+  </EntitySwitch>
+);
+
+// For VCF Deployments
+const hasVcfAutomationDeploymentStatus = (entity: Entity): boolean => 
+  Boolean(entity.metadata?.annotations?.['terasky.backstage.io/vcf-automation-deployment-status']);
+
+const vcfAutomationDeploymentPage = (
+  <EntityLayout>
+    <EntityLayout.Route path="/" title="Overview">
+      <Grid container spacing={3} alignItems="stretch">
+        <Grid item md={6}>
+          <VCFAutomationDeploymentOverview />
+        </Grid>
+      </Grid>
+    </EntityLayout.Route>
+    <EntityLayout.Route path="/vcf-automation" title="VCF Automation">
+      <VCFAutomationDeploymentDetails />
+    </EntityLayout.Route>
+  </EntityLayout>
+);
+
+// For Generic Resources
+const hasVcfAutomationResourceType = (entity: Entity): boolean => 
+  Boolean(entity.metadata?.annotations?.['terasky.backstage.io/vcf-automation-resource-type']);
+
+const vcfAutomationGenericResourcePage = (
+  <EntityLayout>
+    <EntityLayout.Route path="/" title="Overview">
+      <Grid container spacing={3} alignItems="stretch">
+        <Grid item md={6}>
+          <VCFAutomationGenericResourceOverview />
+        </Grid>
+      </Grid>
+    </EntityLayout.Route>
+    <EntityLayout.Route path="/vcf-automation" title="VCF Automation">
+      <VCFAutomationGenericResourceDetails />
+    </EntityLayout.Route>
+  </EntityLayout>
+);
+
+// For Projects (in Domain page)
+const domainPage = (
+  <EntityLayout>
+    <EntityLayout.Route path="/" title="Overview">
+      <Grid container spacing={3} alignItems="stretch">
+        <Grid item md={6}>
+          <VCFAutomationProjectOverview />
+        </Grid>
+      </Grid>
+    </EntityLayout.Route>
+    <EntityLayout.Route path="/vcf-automation" title="VCF Automation">
+      <VCFAutomationProjectDetails />
+    </EntityLayout.Route>
+  </EntityLayout>
+);
+
+// Add a Resources Page
+const resourcePage = (
+  <EntitySwitch>
+    <EntitySwitch.Case if={hasVcfAutomationResourceType}>
+      {vcfAutomationGenericResourcePage}
+    </EntitySwitch.Case>
+    <EntitySwitch.Case>
+      {defaultEntityPage}
+    </EntitySwitch.Case>
+  </EntitySwitch>
+);
+
+// Update the entityPage constant to include the resource page
+export const entityPage = (
+  <EntitySwitch>
+    ...
+    <EntitySwitch.Case if={isKind('resource')} children={resourcePage} />
+    ...
+  </EntitySwitch>
+);
+```
+
+### 5. Configure Backend Integration
+
+Add the following to your `app-config.yaml`:
+
+```yaml
+vcfAutomation:
+  baseUrl: http://your-vcf-automation-service
+```
+
+## Entity Integration
+
+The plugin integrates with different entity types:
+
+### VSphere VM Component
+```yaml
+apiVersion: backstage.io/v1alpha1
+kind: Component
+metadata:
+  name: my-vm
+spec:
+  type: Cloud.vSphere.Machine
+  system: my-deployment  # References parent deployment
+```
+
+### VCF Deployment
+```yaml
+apiVersion: backstage.io/v1alpha1
+kind: System
+metadata:
+  name: my-deployment
+  annotations:
+    terasky.backstage.io/vcf-automation-deployment-status: 'true'
+```
+
+### Generic Resource
+```yaml
+apiVersion: backstage.io/v1alpha1
+kind: Resource
+metadata:
+  name: my-resource
+  annotations:
+    terasky.backstage.io/vcf-automation-resource-type: 'network'
+```
+
+### Project (Domain)
+```yaml
+apiVersion: backstage.io/v1alpha1
+kind: Domain
+metadata:
+  name: my-project
+```
+
+## Features
+
+- **VSphere VM Management**: Detailed view of VM configurations and status
+- **Deployment Operations**: Track deployment status and history
+- **Resource Management**: Monitor various VCF resource types
+- **Project Administration**: Manage VCF project settings and resources
+- **Permission Integration**: Built-in support for Backstage's permission framework
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request on GitHub.
+
+## License
+
+This project is licensed under the Apache-2.0 License.

package/config.d.ts

@@ -0,0 +1,15 @@
+export interface Config {
+  /**
+  * VCF Automation root URL
+  * NOTE: Visibility applies to only this field
+  * @visibility frontend
+  */
+  vcfAutomation?: {
+    /**
+    * VCF Automation root URL
+    * NOTE: Visibility applies to only this field
+    * @visibility frontend
+    */
+    baseUrl: string;
+  }
+}  

package/dist/index.d.ts

@@ -0,0 +1,331 @@
+/// <reference types="react" />
+import * as _backstage_core_plugin_api from '@backstage/core-plugin-api';
+import { DiscoveryApi, IdentityApi } from '@backstage/core-plugin-api';
+import react from 'react';
+
+declare const vcfAutomationPlugin: _backstage_core_plugin_api.BackstagePlugin<{
+    root: _backstage_core_plugin_api.RouteRef<undefined>;
+}, {
+    catalogIndex: _backstage_core_plugin_api.ExternalRouteRef<undefined, false>;
+}, {}>;
+
+declare const VCFAutomationVSphereVMOverview: () => react.JSX.Element;
+
+declare const VCFAutomationProjectOverview: () => react.JSX.Element;
+
+declare const VCFAutomationProjectDetails: () => react.JSX.Element;
+
+declare const VCFAutomationDeploymentDetails: () => react.JSX.Element;
+
+declare const VCFAutomationVSphereVMDetails: () => react.JSX.Element;
+
+declare const VCFAutomationGenericResourceDetails: () => react.JSX.Element;
+
+declare const VCFAutomationGenericResourceOverview: () => react.JSX.Element;
+
+declare const VCFAutomationDeploymentOverview: () => react.JSX.Element;
+
+interface VcfPageable {
+    pageNumber: number;
+    pageSize: number;
+    sort: {
+        empty: boolean;
+        sorted: boolean;
+        unsorted: boolean;
+    };
+    offset: number;
+    paged: boolean;
+    unpaged: boolean;
+}
+interface VcfPageResponse<T> {
+    content: T[];
+    pageable: VcfPageable;
+    totalElements: number;
+    totalPages: number;
+    last: boolean;
+    size: number;
+    number: number;
+    sort: {
+        empty: boolean;
+        sorted: boolean;
+        unsorted: boolean;
+    };
+    numberOfElements: number;
+    first: boolean;
+    empty: boolean;
+}
+interface VcfDeploymentHistory {
+    id: string;
+    name: string;
+    requestedBy: string;
+    actionId: string;
+    deploymentId: string;
+    resourceIds: string[];
+    status: string;
+    details: string;
+    createdAt: string;
+    updatedAt: string;
+    totalTasks: number;
+    completedTasks: number;
+}
+interface VcfDeploymentEvent$1 {
+    id: string;
+    requestId: string;
+    requestedBy: string;
+    resourceIds: string[];
+    name: string;
+    details: string;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface VcfResourceDisk {
+    vm: string;
+    name: string;
+    type: string;
+    shares?: string;
+    vcUuid: string;
+    diskFile?: string;
+    bootOrder?: number;
+    encrypted: boolean;
+    limitIops?: string;
+    capacityGb: number;
+    persistent: boolean;
+    independent?: string;
+    sharesLevel?: string;
+    endpointType: string;
+    resourceLink: string;
+    vmFolderPath?: string;
+    controllerKey: string;
+    diskPlacementRef?: string;
+    existingResource: string;
+    provisioningType?: string;
+    controllerUnitNumber: string;
+}
+interface VcfResourceNetwork {
+    id: string;
+    name: string;
+    address: string;
+    network: string;
+    assignment: string;
+    deviceIndex: number;
+    external_id: string;
+    mac_address: string;
+    resourceName: string;
+    ipv6Addresses?: string[];
+}
+interface VcfResourceExpense {
+    totalExpense: number;
+    computeExpense: number;
+    storageExpense: number;
+    additionalExpense: number;
+    unit: string;
+    lastUpdatedTime: string;
+}
+interface VcfResource {
+    id: string;
+    name: string;
+    type: string;
+    properties: {
+        [key: string]: any;
+        storage?: {
+            disks: VcfResourceDisk[];
+        };
+        networks?: VcfResourceNetwork[];
+    };
+    createdAt: string;
+    syncStatus: string;
+    expense: VcfResourceExpense;
+    origin: string;
+    dependsOn: string[];
+    state: string;
+}
+interface VcfProjectZone {
+    zoneId: string;
+    priority: number;
+    maxNumberInstances: number;
+    allocatedInstancesCount: number;
+    memoryLimitMB: number;
+    allocatedMemoryMB: number;
+    cpuLimit: number;
+    allocatedCpu: number;
+    storageLimitGB: number;
+    allocatedStorageGB: number;
+    id: string;
+}
+interface VcfProject$1 {
+    machineNamingTemplate: string;
+    administrators: Array<{
+        email: string;
+        type: string;
+    }>;
+    members: Array<{
+        email: string;
+        type: string;
+    }>;
+    viewers: Array<{
+        email: string;
+        type: string;
+    }>;
+    supervisors: Array<{
+        email: string;
+        type: string;
+    }>;
+    zones: VcfProjectZone[];
+    constraints: Record<string, unknown>;
+    operationTimeout: number;
+    sharedResources: boolean;
+    placementPolicy: string;
+    customProperties: Record<string, unknown>;
+    name: string;
+    description: string;
+    id: string;
+    organizationId: string;
+    orgId: string;
+    _links: {
+        self: {
+            href: string;
+        };
+    };
+}
+
+interface VcfDeploymentEvent {
+    timestamp: string;
+    status: string;
+    operation: string;
+    user: string;
+    details: string;
+}
+interface VcfDeploymentConfig {
+    key: string;
+    value: string;
+}
+interface VcfDeploymentResponse {
+    content: any;
+    pageable: any;
+    config: VcfDeploymentConfig[];
+    history: VcfDeploymentEvent[];
+}
+interface VcfVSphereVM {
+    id: string;
+    name: string;
+    type: string;
+    properties: {
+        resourceId: string;
+        moref: string;
+        resourceDescLink: string;
+        powerState: string;
+        zone: string;
+        environmentName: string;
+        hasSnapshots: string;
+        computeHostType: string;
+        id: string;
+        memoryGB: string;
+        cpuCount: number;
+        image: string;
+        totalMemoryMB: number;
+        endpointType: string;
+        resourceName: string;
+        tags: string[];
+        softwareName: string;
+        name: string;
+        resourceLink: string;
+        region: string;
+        hostName: string;
+        storage: {
+            disks: Array<{
+                vm: string;
+                name: string;
+                type: string;
+                shares?: string;
+                vcUuid: string;
+                diskFile?: string;
+                bootOrder?: number;
+                encrypted: boolean;
+                limitIops?: string;
+                capacityGb: number;
+                persistent: boolean;
+                independent?: string;
+                sharesLevel?: string;
+                endpointType: string;
+                resourceLink: string;
+                vmFolderPath?: string;
+                controllerKey: string;
+                diskPlacementRef?: string;
+                existingResource: string;
+                provisioningType?: string;
+                controllerUnitNumber: string;
+            }>;
+        };
+        networks: Array<{
+            id: string;
+            name: string;
+            address: string;
+            network: string;
+            assignment: string;
+            deviceIndex: number;
+            external_id: string;
+            mac_address: string;
+            resourceName: string;
+            ipv6Addresses?: string[];
+        }>;
+        areVMActionsDisabled: string;
+        providerId: string;
+        osType: string;
+        instanceUUID: string;
+        componentType: string;
+        address: string;
+        endpointId: string;
+        externalId: string;
+        datacenter: string;
+        datastoreName: string;
+        coreCount: string;
+        primaryMAC: string;
+        computeHostRef: string;
+        snapshotCount: string;
+        accounts: string[];
+        vmFolderPath: string;
+        account: string;
+        vcUuid: string;
+    };
+    createdAt: string;
+    syncStatus: string;
+    expense: {
+        totalExpense: number;
+        computeExpense: number;
+        storageExpense: number;
+        additionalExpense: number;
+        unit: string;
+        lastUpdatedTime: string;
+    };
+    origin: string;
+    dependsOn: string[];
+    state: string;
+}
+type VcfProject = VcfProject$1;
+interface VcfAutomationApi {
+    getDeploymentEvents(deploymentId: string): Promise<VcfDeploymentResponse>;
+    getVSphereVMDetails(deploymentId: string, resourceId: string): Promise<VcfVSphereVM>;
+    getProjectDetails(projectId: string): Promise<VcfProject>;
+    getGenericResourceDetails(deploymentId: string, resourceId: string): Promise<any>;
+    getDeploymentDetails(deploymentId: string): Promise<any>;
+}
+declare const vcfAutomationApiRef: _backstage_core_plugin_api.ApiRef<VcfAutomationApi>;
+declare class VcfAutomationClient implements VcfAutomationApi {
+    private readonly discoveryApi;
+    private readonly identityApi;
+    constructor(options: {
+        discoveryApi: DiscoveryApi;
+        identityApi: IdentityApi;
+    });
+    private getAuthHeaders;
+    getDeploymentEvents(deploymentId: string): Promise<VcfDeploymentResponse>;
+    getVSphereVMDetails(deploymentId: string, resourceId: string): Promise<VcfVSphereVM>;
+    getGenericResourceDetails(deploymentId: string, resourceId: string): Promise<any>;
+    getDeploymentDetails(deploymentId: string): Promise<any>;
+    getProjectDetails(projectId: string): Promise<VcfProject>;
+}
+
+declare const rootRouteRef: _backstage_core_plugin_api.RouteRef<undefined>;
+
+export { VCFAutomationDeploymentDetails, VCFAutomationDeploymentOverview, VCFAutomationGenericResourceDetails, VCFAutomationGenericResourceOverview, VCFAutomationProjectDetails, VCFAutomationProjectOverview, VCFAutomationVSphereVMDetails, VCFAutomationVSphereVMOverview, VcfAutomationApi, VcfAutomationClient, VcfDeploymentEvent$1 as VcfDeploymentEvent, VcfDeploymentHistory, VcfPageResponse, VcfPageable, VcfProject$1 as VcfProject, VcfProjectZone, VcfResource, VcfResourceDisk, VcfResourceExpense, VcfResourceNetwork, rootRouteRef, vcfAutomationApiRef, vcfAutomationPlugin };