Create controller

Content Table

• Create Controller

  • Content Table

  • What a controller should and what it shouldn't to do

  • How to implement a Controller

  • Controller API Reference

Currently all the controllers must be implemented inside of the everdev package.

To create a new controller:

• Clone [e-mail]:tonlabs/everdev.git.

• Create and checkout branch for the new controller.

• Create a folder under src/controllers.

• Implement the controller code.

• Include the new controller in file src/controllers/index.js.

• Create pull request.

What a controller should and what it shouldn't to do

Controller should:

• Expose functionality to the user as a list of commands.

• Install the required tool components on demand (on first usage).

• Start and stop the tool components that acts like a demons.

• Define three commands to control the tool version:

  • version to show the currently installed tool version;

  • update to update the tool to the latest available version;

  • use to select the specified tool version as the current version.

Controller shouldn't:

• Implement tool functionality itself. Controller is a connector between the user and the existing development tool.

• Implement user interaction itself. All user interaction must be implemented exactly in the terms of everdev extensibility.

How to implement a Controller

Create a folder for a new controller:

mkdir src/controllers/foo
cd src/controllers/foo

Create index.ts with the controller's definition:

import { ToolController } from "../../core";
import { versionCommand } from "./version";
import { updateCommand } from "./update";
import { runCommand } from "./run";

export const Foo: ToolController = {
    name: "foo",
    title: "Foo Tool",
    commands: [
        versionCommand,
        updateCommand,
        runCommand,
    ],
};

Create installer.ts to implement all the code related to the tool installation:

import path from "path";
import fs from "fs";
import { Terminal, everdevHome } from "../../core";

function fooHome() {
    return path.resolve(everdevHome(), "foo");
}

async function ensureInstalled(terminal: Terminal) {
}

export async function getVersion(): Promise<string> {
    return "1.0.0";
}

export async function updateVersion(terminal: Terminal) {
    if (fs.existsSync(fooHome())) {
        fs.rmdirSync(fooHome(), { recursive: true });
    }
    ensureInstalled(terminal);
}

export async function runFoo(terminal: Terminal, workDir: string, args: string[]): Promise<void> {
    ensureInstalled(terminal);
    terminal.log("Foo succeeded");
};

Create version.ts command handler:

import { getVersion } from "./installer";
import { Command, Terminal } from "../../core";

export const versionCommand: Command = {
    name: "version",
    title: "Show Foo Version",
    async run(terminal: Terminal, _args: {}): Promise<void> {
        terminal.log(await getVersion());
    },
};

Create update.ts command handler:

import { updateVersion } from "./installer";
import { Command, Terminal } from "../../core";

export const versionCommand: Command = {
    name: "update",
    title: "Update Foo Version",
    async run(terminal: Terminal, _args: {}): Promise<void> {
        await updateVersion(terminal);
    },
};

Create run.ts command handler:

import { runFoo } from "./installer";
import { Command, Terminal } from "../../core";

export const runCommand: Command = {
    name: "run",
    title: "Run Foo",
    async run(terminal: Terminal, args: {}): Promise<void> {
        await runFoo(terminal, args);
    },
};

Controller API Reference

You can find API reference in form of TSDoc in src/core/index.ts.