2023-03-15 19:00:52 +03:00
|
|
|
// Copyright (c) HashiCorp, Inc.
|
|
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
|
2018-03-26 20:40:33 +03:00
|
|
|
package api
|
|
|
|
|
|
|
|
import (
|
2018-07-25 01:49:55 +03:00
|
|
|
"context"
|
2018-11-07 04:21:24 +03:00
|
|
|
"errors"
|
2018-03-26 20:40:33 +03:00
|
|
|
"fmt"
|
|
|
|
"net/http"
|
2020-06-30 18:26:52 +03:00
|
|
|
"time"
|
2018-11-07 04:21:24 +03:00
|
|
|
|
|
|
|
"github.com/mitchellh/mapstructure"
|
2018-03-26 20:40:33 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
// ListPluginsInput is used as input to the ListPlugins function.
|
2018-11-07 04:21:24 +03:00
|
|
|
type ListPluginsInput struct {
|
|
|
|
// Type of the plugin. Required.
|
2023-02-06 17:41:56 +03:00
|
|
|
Type PluginType `json:"type"`
|
2018-11-07 04:21:24 +03:00
|
|
|
}
|
2018-03-26 20:40:33 +03:00
|
|
|
|
|
|
|
// ListPluginsResponse is the response from the ListPlugins call.
|
|
|
|
type ListPluginsResponse struct {
|
2018-11-07 04:21:24 +03:00
|
|
|
// PluginsByType is the list of plugins by type.
|
2023-02-06 17:41:56 +03:00
|
|
|
PluginsByType map[PluginType][]string `json:"types"`
|
2018-11-07 04:21:24 +03:00
|
|
|
|
2022-08-31 21:23:05 +03:00
|
|
|
Details []PluginDetails `json:"details,omitempty"`
|
|
|
|
|
2018-11-20 02:23:48 +03:00
|
|
|
// Names is the list of names of the plugins.
|
|
|
|
//
|
|
|
|
// Deprecated: Newer server responses should be returning PluginsByType (json:
|
|
|
|
// "types") instead.
|
|
|
|
Names []string `json:"names"`
|
2018-03-26 20:40:33 +03:00
|
|
|
}
|
|
|
|
|
2022-08-31 21:23:05 +03:00
|
|
|
type PluginDetails struct {
|
2022-09-29 20:22:33 +03:00
|
|
|
Type string `json:"type"`
|
2022-09-09 23:03:07 +03:00
|
|
|
Name string `json:"name"`
|
|
|
|
Version string `json:"version,omitempty"`
|
|
|
|
Builtin bool `json:"builtin"`
|
|
|
|
DeprecationStatus string `json:"deprecation_status,omitempty" mapstructure:"deprecation_status"`
|
2022-08-31 21:23:05 +03:00
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
// ListPlugins wraps ListPluginsWithContext using context.Background.
|
2018-03-26 20:40:33 +03:00
|
|
|
func (c *Sys) ListPlugins(i *ListPluginsInput) (*ListPluginsResponse, error) {
|
2022-03-24 00:47:43 +03:00
|
|
|
return c.ListPluginsWithContext(context.Background(), i)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ListPluginsWithContext lists all plugins in the catalog and returns their names as a
|
|
|
|
// list of strings.
|
|
|
|
func (c *Sys) ListPluginsWithContext(ctx context.Context, i *ListPluginsInput) (*ListPluginsResponse, error) {
|
|
|
|
ctx, cancelFunc := c.c.withConfiguredTimeout(ctx)
|
|
|
|
defer cancelFunc()
|
|
|
|
|
2022-09-29 20:22:33 +03:00
|
|
|
resp, err := c.c.rawRequestWithContext(ctx, c.c.NewRequest(http.MethodGet, "/v1/sys/plugins/catalog"))
|
2018-12-12 23:33:09 +03:00
|
|
|
if err != nil && resp == nil {
|
2018-03-26 20:40:33 +03:00
|
|
|
return nil, err
|
|
|
|
}
|
2018-12-12 23:36:28 +03:00
|
|
|
if resp == nil {
|
|
|
|
return nil, nil
|
|
|
|
}
|
2018-03-26 20:40:33 +03:00
|
|
|
defer resp.Body.Close()
|
|
|
|
|
2018-12-12 23:33:09 +03:00
|
|
|
secret, err := ParseSecret(resp.Body)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if secret == nil || secret.Data == nil {
|
|
|
|
return nil, errors.New("data from server response is empty")
|
|
|
|
}
|
|
|
|
|
2018-11-07 04:21:24 +03:00
|
|
|
result := &ListPluginsResponse{
|
2023-02-06 17:41:56 +03:00
|
|
|
PluginsByType: make(map[PluginType][]string),
|
2018-11-07 04:21:24 +03:00
|
|
|
}
|
2022-09-29 20:22:33 +03:00
|
|
|
switch i.Type {
|
2023-02-06 17:41:56 +03:00
|
|
|
case PluginTypeUnknown:
|
|
|
|
for _, pluginType := range PluginTypes {
|
2022-05-17 19:41:26 +03:00
|
|
|
pluginsRaw, ok := secret.Data[pluginType.String()]
|
|
|
|
if !ok {
|
|
|
|
continue
|
2018-11-07 04:21:24 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
pluginsIfc, ok := pluginsRaw.([]interface{})
|
|
|
|
if !ok {
|
2022-05-17 19:41:26 +03:00
|
|
|
return nil, fmt.Errorf("unable to parse plugins for %q type", pluginType.String())
|
2018-11-07 04:21:24 +03:00
|
|
|
}
|
|
|
|
|
2022-05-17 19:41:26 +03:00
|
|
|
plugins := make([]string, 0, len(pluginsIfc))
|
|
|
|
for _, nameIfc := range pluginsIfc {
|
2018-11-07 04:21:24 +03:00
|
|
|
name, ok := nameIfc.(string)
|
|
|
|
if !ok {
|
2022-05-17 19:41:26 +03:00
|
|
|
continue
|
2018-11-07 04:21:24 +03:00
|
|
|
}
|
2022-05-17 19:41:26 +03:00
|
|
|
plugins = append(plugins, name)
|
2018-11-07 04:21:24 +03:00
|
|
|
}
|
|
|
|
result.PluginsByType[pluginType] = plugins
|
|
|
|
}
|
2022-09-29 20:22:33 +03:00
|
|
|
default:
|
|
|
|
pluginsRaw, ok := secret.Data[i.Type.String()]
|
|
|
|
if !ok {
|
|
|
|
return nil, fmt.Errorf("no %s entry in returned data", i.Type.String())
|
|
|
|
}
|
|
|
|
|
2018-11-07 04:21:24 +03:00
|
|
|
var respKeys []string
|
2022-09-29 20:22:33 +03:00
|
|
|
if err := mapstructure.Decode(pluginsRaw, &respKeys); err != nil {
|
2018-11-07 04:21:24 +03:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
result.PluginsByType[i.Type] = respKeys
|
|
|
|
}
|
|
|
|
|
2022-08-31 21:23:05 +03:00
|
|
|
if detailed, ok := secret.Data["detailed"]; ok {
|
2022-09-29 20:22:33 +03:00
|
|
|
var details []PluginDetails
|
|
|
|
if err := mapstructure.Decode(detailed, &details); err != nil {
|
2022-08-31 21:23:05 +03:00
|
|
|
return nil, err
|
|
|
|
}
|
2022-09-29 20:22:33 +03:00
|
|
|
|
|
|
|
switch i.Type {
|
2023-02-06 17:41:56 +03:00
|
|
|
case PluginTypeUnknown:
|
2022-09-29 20:22:33 +03:00
|
|
|
result.Details = details
|
|
|
|
default:
|
|
|
|
// Filter for just the queried type.
|
|
|
|
for _, entry := range details {
|
|
|
|
if entry.Type == i.Type.String() {
|
|
|
|
result.Details = append(result.Details, entry)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-08-31 21:23:05 +03:00
|
|
|
}
|
|
|
|
|
2018-11-07 04:21:24 +03:00
|
|
|
return result, nil
|
2018-03-26 20:40:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// GetPluginInput is used as input to the GetPlugin function.
|
|
|
|
type GetPluginInput struct {
|
|
|
|
Name string `json:"-"`
|
2018-11-07 04:21:24 +03:00
|
|
|
|
|
|
|
// Type of the plugin. Required.
|
2023-02-06 17:41:56 +03:00
|
|
|
Type PluginType `json:"type"`
|
|
|
|
Version string `json:"version"`
|
2018-03-26 20:40:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// GetPluginResponse is the response from the GetPlugin call.
|
|
|
|
type GetPluginResponse struct {
|
2022-09-09 23:03:07 +03:00
|
|
|
Args []string `json:"args"`
|
|
|
|
Builtin bool `json:"builtin"`
|
|
|
|
Command string `json:"command"`
|
|
|
|
Name string `json:"name"`
|
|
|
|
SHA256 string `json:"sha256"`
|
|
|
|
DeprecationStatus string `json:"deprecation_status,omitempty"`
|
2022-10-07 17:28:15 +03:00
|
|
|
Version string `json:"version,omitempty"`
|
2018-03-26 20:40:33 +03:00
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
// GetPlugin wraps GetPluginWithContext using context.Background.
|
2018-03-26 20:40:33 +03:00
|
|
|
func (c *Sys) GetPlugin(i *GetPluginInput) (*GetPluginResponse, error) {
|
2022-03-24 00:47:43 +03:00
|
|
|
return c.GetPluginWithContext(context.Background(), i)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetPluginWithContext retrieves information about the plugin.
|
|
|
|
func (c *Sys) GetPluginWithContext(ctx context.Context, i *GetPluginInput) (*GetPluginResponse, error) {
|
|
|
|
ctx, cancelFunc := c.c.withConfiguredTimeout(ctx)
|
|
|
|
defer cancelFunc()
|
|
|
|
|
2018-11-16 01:33:11 +03:00
|
|
|
path := catalogPathByType(i.Type, i.Name)
|
2018-03-26 20:40:33 +03:00
|
|
|
req := c.c.NewRequest(http.MethodGet, path)
|
2022-10-07 17:28:15 +03:00
|
|
|
if i.Version != "" {
|
|
|
|
req.Params.Set("version", i.Version)
|
|
|
|
}
|
2018-07-25 01:49:55 +03:00
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
resp, err := c.c.rawRequestWithContext(ctx, req)
|
2018-03-26 20:40:33 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
2018-07-13 20:35:08 +03:00
|
|
|
var result struct {
|
2018-11-16 01:33:11 +03:00
|
|
|
Data *GetPluginResponse
|
2018-07-13 20:35:08 +03:00
|
|
|
}
|
2018-03-26 20:40:33 +03:00
|
|
|
err = resp.DecodeJSON(&result)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2018-11-16 01:33:11 +03:00
|
|
|
return result.Data, err
|
2018-03-26 20:40:33 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// RegisterPluginInput is used as input to the RegisterPlugin function.
|
|
|
|
type RegisterPluginInput struct {
|
|
|
|
// Name is the name of the plugin. Required.
|
|
|
|
Name string `json:"-"`
|
|
|
|
|
2018-11-07 04:21:24 +03:00
|
|
|
// Type of the plugin. Required.
|
2023-02-06 17:41:56 +03:00
|
|
|
Type PluginType `json:"type"`
|
2018-11-07 04:21:24 +03:00
|
|
|
|
2018-03-26 20:40:33 +03:00
|
|
|
// Args is the list of args to spawn the process with.
|
|
|
|
Args []string `json:"args,omitempty"`
|
|
|
|
|
|
|
|
// Command is the command to run.
|
|
|
|
Command string `json:"command,omitempty"`
|
|
|
|
|
|
|
|
// SHA256 is the shasum of the plugin.
|
|
|
|
SHA256 string `json:"sha256,omitempty"`
|
2022-08-31 21:23:05 +03:00
|
|
|
|
|
|
|
// Version is the optional version of the plugin being registered
|
|
|
|
Version string `json:"version,omitempty"`
|
2018-03-26 20:40:33 +03:00
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
// RegisterPlugin wraps RegisterPluginWithContext using context.Background.
|
2018-03-26 20:40:33 +03:00
|
|
|
func (c *Sys) RegisterPlugin(i *RegisterPluginInput) error {
|
2022-03-24 00:47:43 +03:00
|
|
|
return c.RegisterPluginWithContext(context.Background(), i)
|
|
|
|
}
|
|
|
|
|
|
|
|
// RegisterPluginWithContext registers the plugin with the given information.
|
|
|
|
func (c *Sys) RegisterPluginWithContext(ctx context.Context, i *RegisterPluginInput) error {
|
|
|
|
ctx, cancelFunc := c.c.withConfiguredTimeout(ctx)
|
|
|
|
defer cancelFunc()
|
|
|
|
|
2018-11-16 01:33:11 +03:00
|
|
|
path := catalogPathByType(i.Type, i.Name)
|
2018-03-26 20:40:33 +03:00
|
|
|
req := c.c.NewRequest(http.MethodPut, path)
|
2018-11-16 01:33:11 +03:00
|
|
|
|
2018-03-26 20:40:33 +03:00
|
|
|
if err := req.SetJSONBody(i); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
resp, err := c.c.rawRequestWithContext(ctx, req)
|
2018-03-26 20:40:33 +03:00
|
|
|
if err == nil {
|
|
|
|
defer resp.Body.Close()
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// DeregisterPluginInput is used as input to the DeregisterPlugin function.
|
|
|
|
type DeregisterPluginInput struct {
|
|
|
|
// Name is the name of the plugin. Required.
|
|
|
|
Name string `json:"-"`
|
2018-11-07 04:21:24 +03:00
|
|
|
|
|
|
|
// Type of the plugin. Required.
|
2023-02-06 17:41:56 +03:00
|
|
|
Type PluginType `json:"type"`
|
2022-08-31 21:23:05 +03:00
|
|
|
|
|
|
|
// Version of the plugin. Optional.
|
|
|
|
Version string `json:"version,omitempty"`
|
2018-03-26 20:40:33 +03:00
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
// DeregisterPlugin wraps DeregisterPluginWithContext using context.Background.
|
2018-03-26 20:40:33 +03:00
|
|
|
func (c *Sys) DeregisterPlugin(i *DeregisterPluginInput) error {
|
2022-03-24 00:47:43 +03:00
|
|
|
return c.DeregisterPluginWithContext(context.Background(), i)
|
|
|
|
}
|
|
|
|
|
|
|
|
// DeregisterPluginWithContext removes the plugin with the given name from the plugin
|
|
|
|
// catalog.
|
|
|
|
func (c *Sys) DeregisterPluginWithContext(ctx context.Context, i *DeregisterPluginInput) error {
|
|
|
|
ctx, cancelFunc := c.c.withConfiguredTimeout(ctx)
|
|
|
|
defer cancelFunc()
|
|
|
|
|
2018-11-16 01:33:11 +03:00
|
|
|
path := catalogPathByType(i.Type, i.Name)
|
2018-03-26 20:40:33 +03:00
|
|
|
req := c.c.NewRequest(http.MethodDelete, path)
|
2022-08-31 21:23:05 +03:00
|
|
|
req.Params.Set("version", i.Version)
|
2022-03-24 00:47:43 +03:00
|
|
|
resp, err := c.c.rawRequestWithContext(ctx, req)
|
2018-03-26 20:40:33 +03:00
|
|
|
if err == nil {
|
|
|
|
defer resp.Body.Close()
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
2018-11-16 01:33:11 +03:00
|
|
|
|
2020-05-04 21:14:23 +03:00
|
|
|
// ReloadPluginInput is used as input to the ReloadPlugin function.
|
|
|
|
type ReloadPluginInput struct {
|
|
|
|
// Plugin is the name of the plugin to reload, as registered in the plugin catalog
|
|
|
|
Plugin string `json:"plugin"`
|
|
|
|
|
|
|
|
// Mounts is the array of string mount paths of the plugin backends to reload
|
|
|
|
Mounts []string `json:"mounts"`
|
2020-06-30 18:26:52 +03:00
|
|
|
|
|
|
|
// Scope is the scope of the plugin reload
|
|
|
|
Scope string `json:"scope"`
|
2020-05-04 21:14:23 +03:00
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
// ReloadPlugin wraps ReloadPluginWithContext using context.Background.
|
2020-06-30 18:26:52 +03:00
|
|
|
func (c *Sys) ReloadPlugin(i *ReloadPluginInput) (string, error) {
|
2022-03-24 00:47:43 +03:00
|
|
|
return c.ReloadPluginWithContext(context.Background(), i)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ReloadPluginWithContext reloads mounted plugin backends, possibly returning
|
|
|
|
// reloadId for a cluster scoped reload
|
|
|
|
func (c *Sys) ReloadPluginWithContext(ctx context.Context, i *ReloadPluginInput) (string, error) {
|
|
|
|
ctx, cancelFunc := c.c.withConfiguredTimeout(ctx)
|
|
|
|
defer cancelFunc()
|
|
|
|
|
2020-05-04 21:14:23 +03:00
|
|
|
path := "/v1/sys/plugins/reload/backend"
|
|
|
|
req := c.c.NewRequest(http.MethodPut, path)
|
|
|
|
|
|
|
|
if err := req.SetJSONBody(i); err != nil {
|
2020-06-30 18:26:52 +03:00
|
|
|
return "", err
|
2020-05-04 21:14:23 +03:00
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
resp, err := c.c.rawRequestWithContext(ctx, req)
|
2020-05-04 21:14:23 +03:00
|
|
|
if err != nil {
|
2020-06-30 18:26:52 +03:00
|
|
|
return "", err
|
2020-06-30 00:23:28 +03:00
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
2020-06-30 18:26:52 +03:00
|
|
|
|
|
|
|
if i.Scope == "global" {
|
|
|
|
// Get the reload id
|
|
|
|
secret, parseErr := ParseSecret(resp.Body)
|
|
|
|
if parseErr != nil {
|
2020-06-30 21:33:30 +03:00
|
|
|
return "", parseErr
|
2020-06-30 18:26:52 +03:00
|
|
|
}
|
|
|
|
if _, ok := secret.Data["reload_id"]; ok {
|
|
|
|
return secret.Data["reload_id"].(string), nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
// ReloadStatus is the status of an individual node's plugin reload
|
|
|
|
type ReloadStatus struct {
|
|
|
|
Timestamp time.Time `json:"timestamp" mapstructure:"timestamp"`
|
2020-07-01 00:26:38 +03:00
|
|
|
Error string `json:"error" mapstructure:"error"`
|
2020-06-30 18:26:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// ReloadStatusResponse is the combined response of all known completed plugin reloads
|
|
|
|
type ReloadStatusResponse struct {
|
|
|
|
ReloadID string `mapstructure:"reload_id"`
|
|
|
|
Results map[string]*ReloadStatus `mapstructure:"results"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// ReloadPluginStatusInput is used as input to the ReloadStatusPlugin function.
|
|
|
|
type ReloadPluginStatusInput struct {
|
|
|
|
// ReloadID is the ID of the reload operation
|
|
|
|
ReloadID string `json:"reload_id"`
|
|
|
|
}
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
// ReloadPluginStatus wraps ReloadPluginStatusWithContext using context.Background.
|
2020-06-30 18:26:52 +03:00
|
|
|
func (c *Sys) ReloadPluginStatus(reloadStatusInput *ReloadPluginStatusInput) (*ReloadStatusResponse, error) {
|
2022-03-24 00:47:43 +03:00
|
|
|
return c.ReloadPluginStatusWithContext(context.Background(), reloadStatusInput)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ReloadPluginStatusWithContext retrieves the status of a reload operation
|
|
|
|
func (c *Sys) ReloadPluginStatusWithContext(ctx context.Context, reloadStatusInput *ReloadPluginStatusInput) (*ReloadStatusResponse, error) {
|
|
|
|
ctx, cancelFunc := c.c.withConfiguredTimeout(ctx)
|
|
|
|
defer cancelFunc()
|
|
|
|
|
2020-06-30 18:26:52 +03:00
|
|
|
path := "/v1/sys/plugins/reload/backend/status"
|
|
|
|
req := c.c.NewRequest(http.MethodGet, path)
|
|
|
|
req.Params.Add("reload_id", reloadStatusInput.ReloadID)
|
|
|
|
|
2022-03-24 00:47:43 +03:00
|
|
|
resp, err := c.c.rawRequestWithContext(ctx, req)
|
2020-06-30 18:26:52 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
if resp != nil {
|
|
|
|
secret, parseErr := ParseSecret(resp.Body)
|
|
|
|
if parseErr != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
var r ReloadStatusResponse
|
|
|
|
d, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
|
|
|
|
DecodeHook: mapstructure.StringToTimeHookFunc(time.RFC3339),
|
|
|
|
Result: &r,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
err = d.Decode(secret.Data)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &r, nil
|
|
|
|
}
|
|
|
|
return nil, nil
|
2020-05-04 21:14:23 +03:00
|
|
|
}
|
|
|
|
|
2018-11-16 01:33:11 +03:00
|
|
|
// catalogPathByType is a helper to construct the proper API path by plugin type
|
2023-02-06 17:41:56 +03:00
|
|
|
func catalogPathByType(pluginType PluginType, name string) string {
|
2018-11-16 01:33:11 +03:00
|
|
|
path := fmt.Sprintf("/v1/sys/plugins/catalog/%s/%s", pluginType, name)
|
|
|
|
|
|
|
|
// Backwards compat, if type is not provided then use old path
|
2023-02-06 17:41:56 +03:00
|
|
|
if pluginType == PluginTypeUnknown {
|
2018-11-16 01:33:11 +03:00
|
|
|
path = fmt.Sprintf("/v1/sys/plugins/catalog/%s", name)
|
|
|
|
}
|
|
|
|
|
|
|
|
return path
|
|
|
|
}
|