Morpheus Plugin Documentation

String itsmEndpoint = accountIntegration.configMap?.cm?.plugin?."itsm-endpoint"

String myPolicyConfigValue = policy.configMap?."my-policy-config-option"

class MyPlugin extends Plugin {

        @Override
        String getCode() {
                return 'my-plugin'
        }

        @Override
        String getName() {
                return 'My Plugin'
        }

        @Override
        void initialize() {
                MyPluginBackupProvider backupProvider = new MyPluginBackupProvider(this, morpheus)
                registerProvider(backupProvider)
        }

class MyPluginBackupProvider extends AbstractBackupProvider {

        MyPluginBackupProvider(Plugin plugin, MorpheusContext morpheusContext) {
                super(plugin, morpheusContext)

                MyVmwareBackupProvider vmwareBackupProvider = new MyVmwareBackupProvider(plugin, morpheus)
                plugin.registerProvider(vmwareBackupProvider)
                addScopedProvider(vmwareBackupProvider, "vmware", null)

                MyHypervBackupProvider hypervBackupProvider = new MyHypervBackupProvider(plugin, morpheus)
                plugin.registerProvider(hypervBackupProvider)
                addScopedProvider(hypervBackupProvider, "hyperv", null)
        }

        @Override
        String getCode() {
                return 'my-backup-provider'
        }

        @Override
        String getName() {
                return 'My Backup Provider'
        }

        @Override
        Icon getIcon() {
                return new Icon(path:"icon.svg", darkPath: "icon-dark.svg")
        }

        ...
}

class MyVmwareBackupProvider extends AbstractBackupTypeProvider {

        MyVmwareBackupProvider(Plugin plugin, MorpheusContext context) {
                super(plugin, context)
        }

        @Override
        String getCode() {
                return "my-vmware-backup-provider"
        }

        @Override
        String getName() {
                return "MY VMware backup provider"
        }

        @Override
        Collection<OptionType> getOptionTypes() {
                return new ArrayList()
        }

        @Override
        BackupExecutionProvider getExecutionProvider() {
                return new SnapshotExecutionProvider()
        }

        @Override
        BackupRestoreProvider getRestoreProvider() {
                return new SnapshotRestoreProvider()
        }

        ...
}

@Slf4j
class MyPluginBackupProvider extends AbstractBackupProvider {

        /... .../

        @Override
        ServiceResponse refresh(BackupProvider backupProvider) {
                ServiceResponse rtn = ServiceResponse.prepare()
                try {
                        new BackupSyncTask().execute()
                } catch(Exception e) {
                        log.error("error refreshing backup provider {}::{}: {}", plugin.name, this.name, e)
                }
                return rtn
        }

        /... .../

}

class MyBackupTabProvider extends AbstractBackupIntegrationTabProvider {

        /... .../

        @Override
        HTMLResponse renderTemplate(BackupProvider backupProvider) {
                ViewModel<BackupProvider> model = new ViewModel<>()
                model.object = backupProvider

                return getRenderer().renderTemplate("hbs/myTabView", model)
        }

        @Override
        Boolean show(BackupProvider backupProvider, User user, Account account) {
                // only show this tab for providers that match this plugin's backup provider
                return backupProvider.type.code == MyBackupProvider.PROVIDER_CODE
        }

}

class MyBackupProvider extends AbstractBackupProvider {

        private HandlebarsRenderer renderer

        /... .../

        @Override
        HTMLResponse renderTemplate(com.morpheusdata.model.BackupProvider backupProvider) {
                ViewModel<com.morpheusdata.model.BackupProvider> model = new ViewModel<>()
                model.object = backupProvider

                return getRenderer().renderTemplate("hbs/myBackupProviderView", model)
        }

        // we need to implement a renderer to use handlebars
        Renderer<?> getRenderer() {
                if(renderer == null) {
                        renderer = new HandlebarsRenderer("renderer", getPlugin().getClassLoader())
                        renderer.registerAssetHelper(getPlugin().getName())
                        renderer.registerNonceHelper(getMorpheus().getWebRequest())
                        renderer.registerI18nHelper(getPlugin(),getMorpheus())
                }
                return renderer
        }
}

class MyBackupProvider extends MorpheusBackupProvider {

        MyBackupProvider(Plugin plugin, MorpheusContext context) {
                super(plugin, context)

                MySnapshotBackupProvider mySnapshotBackupProvider = new MySnapshotBackupProvider(plugin, morpheus)
                plugin.registerProvider(mySnapshotBackupProvider)
                addScopedProvider(mySnapshotBackupProvider, "vmware", null)
        }

}

/**
 * Example TabProvider
 */
class StandardCatalogLayoutProvider extends AbstractCatalogItemLayoutProvider {
        Plugin plugin
        MorpheusContext morpheus

        String code = 'catalog-item-standard'
        String name = 'Standard Catalog Layout'

        StandardCatalogLayoutProvider(Plugin plugin, MorpheusContext context) {
                this.plugin = plugin
                this.morpheus = context
        }

    /**
     * Demonstrates building a TaskConfig to get details about the Server and renders the html from the specified template.
     * @param server details of a ComputeServer
     * @return
     */
        @Override
    HTMLResponse renderTemplate(CatalogItemType catalogItemType, User user) {
        ViewModel<CatalogItemType> model = new ViewModel<>()
        model.object = catalogItemType
        getRenderer().renderTemplate("hbs/standardCatalogItem", model)
    }

}

<script src="{{asset "/form_manager.js"}}" ></script>
<link rel="stylesheet" type="text/css" href="{{asset "/styles.css"}}">
<script src="{{asset "/templates/plugin-configurable-option.js"}}" ></script>
<div class="page-content">
        <div class="catalog-item-details">
                <div class="item-type-header">
                        <div class="item-type-image">
                                <img class="item-header-img" src="{{catalogTypeImage}}" title="{{name}}" onError="loadImage(this);"/>
                        </div>
                        <h1 class="ellipsize" title="{{name}}">{{name}}</h1>
                        <div class="desc">{{description}}</div>
                </div>
                <div class="catalog-item-body break-container-sm">
                        {{#hasWiki}}
                                <div class="catalog-item-content wiki-content">
                                        {{wiki}}
                                </div>
                        {{/hasWiki}}
                        <div class="catalog-item-configuration {{#hasWiki}}with-item-content{{/hasWiki}}">
                                {{#orderForm}}
                                        <div class="actions text-right">

                                        </div>
                                {{/orderForm}}
                        </div>
                </div>
        </div>
</div>

class MyCustomDatastoreTypeProvider implements DatastoreTypeProvider, DatastoreTypeProvider.MvmProvisionFacet, DatastoreTypeProvider.SnapshotFacet.SnapshotServerFacet {

        @Override
        String getStorageProviderCode() {
                return 'my-storage-provider-code'
        }
// Implement required methods here for all 3 interfaces

}

class MyCustomStorageProvider implements StorageProvider {
        @Override
        String getCode() {
                return 'my-storage-provider-code'
        }
}

void process(ReportResult reportResult) {
  morpheus.report.updateReportResultStatus(reportResult,ReportResult.Status.generating).blockingGet()
  Long displayOrder = 0
  List<GroovyRowResult> results = []
  withDbConnection { Connection dbConnection ->
    if(reportResult.configMap?.phrase) {
      String phraseMatch = "${reportResult.configMap?.phrase}%"
      results = new Sql(dbConnection).rows("SELECT id,name,status from instance WHERE name LIKE ${phraseMatch} order by name asc;")
    } else {
      results = new Sql(dbConnection).rows("SELECT id,name,status from instance order by name asc;")
    }
  }

Observable<GroovyRowResult> observable = Observable.fromIterable(results) as Observable<GroovyRowResult>
  observable.map{ resultRow ->
    Map<String,Object> data = [name: resultRow.name, id: resultRow.id, status: resultRow.status]
    ReportResultRow resultRowRecord = new ReportResultRow(section: ReportResultRow.SECTION_MAIN, displayOrder: displayOrder++, dataMap: data)
    return resultRowRecord
  }.buffer(50).doOnComplete {
    morpheus.report.updateReportResultStatus(reportResult,ReportResult.Status.ready).blockingGet()
  }.doOnError { Throwable t ->
    morpheus.report.updateReportResultStatus(reportResult,ReportResult.Status.failed).blockingGet()
  }.subscribe {resultRows ->
    morpheus.report.appendResultRows(reportResult,resultRows).blockingGet()
  }
}

@Override
List<OptionType> getOptionTypes() {
  [new OptionType(code: 'status-report-search', name: 'Search', fieldName: 'phrase', fieldContext: 'config', fieldLabel: 'Search Phrase', displayOrder: 0)]
}

@Override
HTMLResponse renderTemplate(ReportResult reportResult, Map<String, List<ReportResultRow>> reportRowsBySection) {
    ViewModel<String> model = new ViewModel<String>()
    model.object = reportRowsBySection
    getRenderer().renderTemplate("hbs/instanceReport", model)
}

plugins {
    id "com.github.johnrengelman.shadow" version "8.1.1"
}

apply plugin: 'java'
apply plugin: 'groovy'

group = 'com.example.storage'
version = '1.0.0'

sourceCompatibility = '11'
targetCompatibility = '11'

dependencies {
    compileOnly 'com.morpheusdata:morpheus-plugin-api:1.3.0'
    compileOnly 'org.codehaus.groovy:groovy-all:3.0.21'

    // Your SDS client library
    implementation 'com.example:storpool-client:1.0.0'
}

jar {
    manifest {
        attributes(
            'Plugin-Class': 'com.example.storage.MyStoragePlugin',
            'Plugin-Version': archiveVersion.get(),
            'Morpheus-Name': 'My SDS Storage',
            'Morpheus-Organization': 'My Organization',
            'Morpheus-Code': 'my-sds-storage-plugin',
            'Morpheus-Description': 'SDS Storage Integration for HVM',
            'Morpheus-Min-Appliance-Version': '8.0.0'
        )
    }
}

tasks.assemble.dependsOn tasks.shadowJar

class MyStoragePlugin extends Plugin {

    @Override
    String getCode() {
        return 'my-sds-storage-plugin'
    }

    @Override
    void initialize() {
        this.name = 'My SDS Storage'
        this.description = 'SDS Storage Integration for HVM'

        // Register the storage server integration provider
        this.registerProvider(new MySdsStorageProvider(this, this.morpheus))

        // Register the HVM datastore type provider
        this.registerProvider(new MySdsDatastoreProvider(this, this.morpheus))

        // Register any dataset providers for dynamic UI dropdowns
        this.registerProvider(new StoragePoolDatasetProvider(this, this.morpheus))
    }

    @Override
    void onDestroy() {
        // Cleanup resources
    }
}

class MySdsStorageProvider extends AbstractStorageProvider
        implements StorageProviderVolumes {

    MorpheusContext morpheusContext
    Plugin plugin

    MySdsStorageProvider(Plugin plugin, MorpheusContext morpheusContext) {
        super(plugin, morpheusContext)
        this.morpheusContext = morpheusContext
        this.plugin = plugin
    }

    @Override
    String getCode() {
        return 'my-sds-storage'
    }

    @Override
    String getName() {
        return 'My SDS Storage'
    }

    @Override
    String getDescription() {
        return 'SDS Storage Array Integration'
    }

    @Override
    Icon getIcon() {
        return new Icon(path: 'my-sds-logo.svg', darkPath: 'my-sds-logo-dark.svg')
    }

    @Override
    StorageServerType getStorageServerType() {
        return new StorageServerType(
            code: 'my-sds-storage',
            name: 'My SDS Storage',
            description: 'SDS Storage Array',
            hasBlock: true,
            hasObject: false,
            hasFile: false,
            hasDisk: true,
            optionTypes: getStorageServerOptionTypes(),
            volumeTypes: getStorageVolumeTypes()
        )
    }

    @Override
    ServiceResponse verifyStorageServer(StorageServer storageServer, Map opts) {
        // Validate connectivity and credentials against the SDS API
        // Return ServiceResponse.error() with field-level errors if validation fails
    }

    @Override
    ServiceResponse initializeStorageServer(StorageServer storageServer, Map opts) {
        // Called on first save. Perform initial sync of pools, volumes, etc.
        return refreshStorageServer(storageServer, opts)
    }

    @Override
    ServiceResponse refreshStorageServer(StorageServer storageServer, Map opts) {
        // Periodic sync: update capacity, discover volumes, sync pools
        // Use SyncTask for efficient delta sync of large datasets
    }

    // StorageProviderVolumes methods for managing volumes from the Storage UI
    @Override
    Collection<StorageVolumeType> getStorageVolumeTypes() {
        return [
            new StorageVolumeType(
                code: 'my-sds-block-volume',
                name: 'SDS Block Volume',
                displayOrder: 0
            )
        ]
    }

    // ... implement createVolume, deleteVolume, resizeVolume, updateVolume ...
}

class MySdsDatastoreProvider implements
        DatastoreTypeProvider,
        DatastoreTypeProvider.MvmProvisionFacet,
        DatastoreTypeProvider.SnapshotFacet.SnapshotServerFacet,
        PluginProvider.EventSubscriberFacet {

    MorpheusContext morpheusContext
    Plugin plugin

    MySdsDatastoreProvider(Plugin plugin, MorpheusContext morpheusContext) {
        this.morpheusContext = morpheusContext
        this.plugin = plugin
    }

    @Override
    MorpheusContext getMorpheus() { return morpheusContext }

    @Override
    Plugin getPlugin() { return plugin }

    @Override
    String getCode() { return 'my-sds-hvm-block' }

    @Override
    String getName() { return 'My SDS Block Storage HVM' }

    @Override
    String getProvisionTypeCode() { return 'kvm' }

    @Override
    String getStorageProviderCode() { return 'my-sds-storage' }

    @Override
    boolean getCreatable() { return true }

    @Override
    boolean getEditable() { return true }

    @Override
    boolean getRemovable() { return true }

    @Override
    List<OptionType> getOptionTypes() {
        // Return option types for the datastore creation dialog
        // e.g., storage server selector, pool selector, protocol type
    }

    @Override
    List<StorageVolumeType> getVolumeTypes() {
        // Return the volume types available for this datastore
    }

    // ... lifecycle methods follow ...
}

@Override
List<EventType> getSupportedEventTypes() {
    return [
        EventType.VOLUME_ATTACH,
        EventType.VOLUME_DETACH,
        EventType.ADD_WORKER,
        EventType.REMOVE_WORKER
    ]
}

@Override
ServiceResponse onEvent(Event event) {
    switch (event) {
        case ClusterEvent:
            // ADD_WORKER: Register new host with storage array
            //   (add initiators to host set)
            // REMOVE_WORKER: Unregister host from storage array
            break
        case DatastoreEvent:
            // VOLUME_ATTACH: Ensure volume is mapped to host
            // VOLUME_DETACH: Clean up volume mapping from host
            break
    }
    return ServiceResponse.success()
}

// Execute a command on the hypervisor host
ComputeServer hypervisor = server.parentServer
TaskResult result = morpheusContext.executeCommandOnServer(
    hypervisor,
    'multipathd show paths format "%w %d %s"'
).blockingGet()

if (result.success) {
    String output = result.data
    // Parse multipath output
}

MorpheusVmeQcow2DatastoreService qcowService =
    morpheusContext.services.storage.vmeQcow2DatastoreService

class MySdsFilesystemDatastoreProvider implements
        DatastoreTypeProvider {

    // Datastore lifecycle -- custom (mount the filesystem,
    // register hosts, etc.)
    @Override
    ServiceResponse<Datastore> createDatastore(Datastore ds) {
        // Mount the SDS filesystem on each cluster host
        // Set ds.externalPath to the mount point
    }

    // Volume operations -- delegate to built-in QCOW2 service
    @Override
    ServiceResponse<StorageVolume> createVolume(
            StorageVolume volume, ComputeServer server) {
        return morpheusContext.services.storage
            .vmeQcow2DatastoreService
            .createVolume(volume, server)
    }

    @Override
    ServiceResponse<StorageVolume> cloneVolume(
            StorageVolume volume, ComputeServer server,
            StorageVolume sourceVolume) {
        return morpheusContext.services.storage
            .vmeQcow2DatastoreService
            .cloneVolume(volume, server, sourceVolume)
    }

    @Override
    ServiceResponse<StorageVolume> cloneVolume(
            StorageVolume volume, ComputeServer server,
            VirtualImage virtualImage,
            CloudFileInterface cloudFile) {
        return morpheusContext.services.storage
            .vmeQcow2DatastoreService
            .cloneVolume(volume, server,
                virtualImage, cloudFile)
    }

    @Override
    ServiceResponse<StorageVolume> resizeVolume(
            StorageVolume volume, ComputeServer server,
            Long newSize) {
        return morpheusContext.services.storage
            .vmeQcow2DatastoreService
            .resizeVolume(volume, server, newSize)
    }

    @Override
    ServiceResponse removeVolume(
            StorageVolume volume, ComputeServer server,
            boolean removeSnapshots, boolean force) {
        return morpheusContext.services.storage
            .vmeQcow2DatastoreService
            .removeVolume(volume, server,
                removeSnapshots, force)
    }

    // ... datastore lifecycle methods ...
}

class MySdsHostPackageProvider implements
        ComputeTypePackageProvider {

    MorpheusContext morpheusContext
    Plugin plugin

    MySdsHostPackageProvider(Plugin plugin,
            MorpheusContext morpheusContext) {
        this.morpheusContext = morpheusContext
        this.plugin = plugin
    }

    @Override
    String getCode() { return 'my-sds-host-package' }

    @Override
    String getName() { return 'My SDS Host Agent' }

    @Override
    String getDescription() {
        return 'Installs SDS client tools on cluster hosts'
    }

    @Override
    String getType() { return 'my-sds-agent' }

    @Override
    String getPackageType() { return 'storage' }

    @Override
    String getProviderType() { return 'mvm' }

    @Override
    String getPackageVersion() { return '1.0.0' }

    @Override
    Icon getCircularIcon() {
        return new Icon(path: 'my-sds-icon.svg',
            darkPath: 'my-sds-icon-dark.svg')
    }

    @Override
    List<OptionType> getOptionTypes() {
        // Optional: configuration options for the package
        // (e.g., SDS cluster endpoint, auth token)
        return []
    }

    @Override
    ServiceResponse<ComputeServerGroupPackage> installPackage(
            ComputeServerGroup serverGroup,
            ComputeServerGroupPackage pkg,
            PackageInstallRequest request) {
        // Get all hosts in the cluster
        List<ComputeServer> hosts =
            morpheusContext.services.computeServer.list(
                new DataQuery().withFilter(
                    'serverGroup.id', serverGroup.id
                ).withFilter(
                    'computeServerType.nodeType', 'morpheus-kvm-node'
                )
            )

        // Install the SDS client on each host
        hosts.each { host ->
            def result =
                morpheusContext.executeCommandOnServer(
                    host,
                    'apt-get install -y my-sds-client ' +
                    'multipath-tools open-iscsi'
                ).blockingGet()
            if (!result.success) {
                return ServiceResponse.error(
                    "Install failed on ${host.name}: " +
                    "${result.data}"
                )
            }
        }

        pkg.installed = true
        pkg.status = 'ok'
        return ServiceResponse.success(pkg)
    }

    @Override
    ServiceResponse deletePackage(
            ComputeServerGroup serverGroup,
            ComputeServerGroupPackage pkg,
            PackageDeleteRequest request) {
        // Uninstall the SDS client from each host
        return ServiceResponse.success()
    }
}

class MyStoragePlugin extends Plugin {
    @Override
    void initialize() {
        // ... other providers ...
        this.registerProvider(
            new MySdsHostPackageProvider(this, this.morpheus)
        )
    }
}

        @Override
        List<OptionType> getOptionTypes() {
                OptionType optionType = new OptionType(
                                name: 'myTask',
                                code: 'myTaskText',
                                fieldName: 'myTask',
                                optionSource: true,
                                displayOrder: 0,
                                fieldLabel: 'Text to Reverse',
                                required: true,
                                inputType: OptionType.InputType.TEXT
                )
                return [optionType]
        }

@Override
HTMLResponse renderTemplate(Instance instance) {
  ViewModel<Instance> model = new ViewModel<>()
  model.object = instance
  getRenderer().renderTemplate("hbs/instanceTab", model)
}

@Override
HTMLResponse renderTemplate(ComputeServer server) {
  ViewModel<ComputeServer> model = new ViewModel<>()
  model.object = server
  getRenderer().renderTemplate("hbs/serverTab", model)
}