[Backport 2.x] Add support for dynamic application configurations

config/opensearch_dashboards.yml

@@ -29,6 +29,13 @@
 # dashboards. OpenSearch Dashboards creates a new index if the index doesn't already exist.
 #opensearchDashboards.index: ".opensearch_dashboards"
 
+# OpenSearch Dashboards uses an index in OpenSearch to store dynamic configurations.
+# This shall be a different index from opensearchDashboards.index.
+# opensearchDashboards.configIndex: ".opensearch_dashboards_config"
+
+# Set the value of this setting to true to enable plugin application config. By default it is disabled.
+# application_config.enabled: false
+
 # The default application to load.
 #opensearchDashboards.defaultAppId: "home"
 

src/core/server/mocks.ts

@@ -77,6 +77,7 @@ export function pluginInitializerContextConfigMock<T>(config: T) {
   const globalConfig: SharedGlobalConfig = {
     opensearchDashboards: {
       index: '.opensearch_dashboards_tests',
+      configIndex: '.opensearch_dashboards_config_tests',
       autocompleteTerminateAfter: duration(100000),
       autocompleteTimeout: duration(1000),
     },

src/core/server/opensearch_dashboards_config.ts

@@ -48,6 +48,7 @@ export const config = {
   schema: schema.object({
     enabled: schema.boolean({ defaultValue: true }),
     index: schema.string({ defaultValue: '.kibana' }),
+    configIndex: schema.string({ defaultValue: '.opensearch_dashboards_config' }),
     autocompleteTerminateAfter: schema.duration({ defaultValue: 100000 }),
     autocompleteTimeout: schema.duration({ defaultValue: 1000 }),
     branding: schema.object({

src/core/server/plugins/plugin_context.test.ts

@@ -98,6 +98,7 @@ describe('createPluginInitializerContext', () => {
     expect(configObject).toStrictEqual({
       opensearchDashboards: {
         index: '.kibana',
+        configIndex: '.opensearch_dashboards_config',
         autocompleteTerminateAfter: duration(100000),
         autocompleteTimeout: duration(1000),
       },

src/core/server/plugins/types.ts

@@ -287,7 +287,12 @@ export interface Plugin<
 
 export const SharedGlobalConfigKeys = {
   // We can add more if really needed
-  opensearchDashboards: ['index', 'autocompleteTerminateAfter', 'autocompleteTimeout'] as const,
+  opensearchDashboards: [
+    'index',
+    'configIndex',
+    'autocompleteTerminateAfter',
+    'autocompleteTimeout',
+  ] as const,
   opensearch: ['shardTimeout', 'requestTimeout', 'pingTimeout'] as const,
   path: ['data'] as const,
   savedObjects: ['maxImportPayloadBytes'] as const,

src/legacy/server/config/schema.js

@@ -227,6 +227,7 @@ export default () =>
     opensearchDashboards: Joi.object({
       enabled: Joi.boolean().default(true),
       index: Joi.string().default('.kibana'),
+      configIndex: Joi.string().default('.opensearch_dashboards_config'),
       autocompleteTerminateAfter: Joi.number().integer().min(1).default(100000),
       // TODO Also allow units here like in opensearch config once this is moved to the new platform
       autocompleteTimeout: Joi.number().integer().min(1).default(1000),

src/plugins/application_config/README.md

@@ -0,0 +1,112 @@
+# ApplicationConfig Plugin
+
+An OpenSearch Dashboards plugin for application configuration and a default implementation based on OpenSearch as storage.
+
+---
+
+## Introduction
+
+This plugin introduces the support of dynamic application configurations as opposed to the existing static configuration in OSD YAML file `opensearch_dashboards.yml`. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.configIndex` in OSD YAML file. Initially the new index does not exist. Only OSD users who need dynamic configurations will create it.
+
+It also provides an interface `ConfigurationClient` for future extensions of external configuration clients. A default implementation based on OpenSearch as database is used.
+
+This plugin is disabled by default.
+
+## Configuration
+
+OSD users who want to set up application configurations will first need to enable this plugin by the following line in OSD YML.
+
+```
+application_config.enabled: true
+
+```
+
+Then they can perform configuration operations through CURL the OSD APIs.
+
+(Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names)
+
+Below is the CURL command to view all configurations.
+
+```
+curl '{osd endpoint}/api/appconfig' -X GET
+```
+
+Below is the CURL command to view the configuration of an entity.
+
+```
+curl '{osd endpoint}/api/appconfig/{entity}' -X GET
+
+```
+
+Below is the CURL command to update the configuration of an entity.
+
+```
+curl '{osd endpoint}/api/appconfig/{entity}' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"newValue":"{new value}"}'
+```
+
+Below is the CURL command to delete the configuration of an entity.
+
+```
+curl '{osd endpoint}/api/appconfig/{entity}' -X DELETE -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty'
+
+```
+
+
+## External Configuration Clients
+
+While a default OpenSearch based client is implemented, OSD users can use external configuration clients through an OSD plugin (outside OSD).
+
+Let's call this plugin `MyConfigurationClientPlugin`.
+
+First, this plugin will need to implement a class `MyConfigurationClient` based on interface `ConfigurationClient` defined in the `types.ts` under directory `src/plugins/application_config/server/types.ts`. Below are the functions inside the interface.
+
+```
+  getConfig(): Promise<Map<string, string>>;
+
+  getEntityConfig(entity: string): Promise<string>;
+
+  updateEntityConfig(entity: string, newValue: string): Promise<string>;
+
+  deleteEntityConfig(entity: string): Promise<string>;
+```
+
+Second, this plugin needs to declare `applicationConfig` as its dependency by adding it to `requiredPlugins` in its own `opensearch_dashboards.json`.
+
+Third, the plugin will define a new type called `AppPluginSetupDependencies` as follows in its own `types.ts`.
+
+```
+export interface AppPluginSetupDependencies {
+  applicationConfig: ApplicationConfigPluginSetup;
+}
+
+```
+
+Then the plugin will import the new type `AppPluginSetupDependencies` and add to its own setup input. Below is the skeleton of the class `MyConfigurationClientPlugin`.
+
+```
+// MyConfigurationClientPlugin
+  public setup(core: CoreSetup, { applicationConfig }: AppPluginSetupDependencies) {
+
+    ...
+    // The function createClient provides an instance of ConfigurationClient which
+    // could have a underlying DynamoDB or Postgres implementation.
+    const myConfigurationClient: ConfigurationClient = this.createClient();
+
+    applicationConfig.registerConfigurationClient(myConfigurationClient);
+     ...
+    return {};
+  }
+
+```
+
+## Onboarding Configurations
+
+Since the APIs and interfaces can take an entity, a new use case to this plugin could just pass their entity into the parameters. There is no need to implement new APIs or interfaces. To programmatically call the functions in `ConfigurationClient` from a plugin (the caller plugin), below is the code example.
+
+Similar to [section](#external-configuration-clients), a new type `AppPluginSetupDependencies` which encapsulates `ApplicationConfigPluginSetup` is needed. Then it can be imported into the `setup` function of the caller plugin. Then the caller plugin will have access to the `getConfigurationClient` and `registerConfigurationClient` exposed by `ApplicationConfigPluginSetup`.
+
+## Development
+
+See the [OpenSearch Dashboards contributing
+guide](https://github.com/opensearch-project/OpenSearch-Dashboards/blob/main/CONTRIBUTING.md) for instructions
+setting up your development environment.

src/plugins/application_config/common/index.ts

@@ -0,0 +1,7 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export const PLUGIN_ID = 'applicationConfig';
+export const PLUGIN_NAME = 'application_config';

src/plugins/application_config/config.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { schema, TypeOf } from '@osd/config-schema';
+
+export const configSchema = schema.object({
+  enabled: schema.boolean({ defaultValue: false }),
+});
+
+export type ApplicationConfigSchema = TypeOf<typeof configSchema>;

src/plugins/application_config/opensearch_dashboards.json

@@ -0,0 +1,9 @@
+{
+  "id": "applicationConfig",
+  "version": "opensearchDashboards",
+  "opensearchDashboardsVersion": "opensearchDashboards",
+  "server": true,
+  "ui": false,
+  "requiredPlugins": [],
+  "optionalPlugins": []
+}

src/plugins/application_config/server/index.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { PluginConfigDescriptor, PluginInitializerContext } from '../../../core/server';
+import { ApplicationConfigSchema, configSchema } from '../config';
+import { ApplicationConfigPlugin } from './plugin';
+
+/*
+This exports static code and TypeScript types,
+as well as, OpenSearch Dashboards Platform `plugin()` initializer.
+*/
+
+export const config: PluginConfigDescriptor<ApplicationConfigSchema> = {
+  schema: configSchema,
+};
+
+export function plugin(initializerContext: PluginInitializerContext) {
+  return new ApplicationConfigPlugin(initializerContext);
+}
+
+export { ApplicationConfigPluginSetup, ApplicationConfigPluginStart } from './types';